@coderyo/core 1.0.2 → 1.1.0

package/dist/index.js

@@ -1,14 +1,414 @@
 // src/bridge-wire.ts
 import {
   BRIDGE_SCHEMA_VERSION,
-  isBridgeInbound
+  isBridgeInbound,
+  isBridgeLayerInboundType as isBridgeLayerInboundType2,
+  LAYER_API_READY
 } from "@coderyo/bridge";
 
+// src/bridge-layer-wire.ts
+import {
+  bridgeLayerPayloadHasDeprecatedLayerId,
+  isBridgeLayerInboundType
+} from "@coderyo/bridge";
+
+// src/merge-layer-bridge-preset.ts
+function upsertById(current, incoming) {
+  if (!incoming?.length) return current.map((x) => ({ ...x }));
+  const map = new Map(current.map((x) => [x.id, { ...x }]));
+  for (const item of incoming) {
+    if (!item?.id) continue;
+    map.set(item.id, { ...item });
+  }
+  return [...map.values()];
+}
+function mergeLayers(current, incoming) {
+  if (!incoming?.length) return current.map((l) => ({ ...l }));
+  const map = new Map(current.map((l) => [l.id, { ...l }]));
+  for (const raw of incoming) {
+    if (!raw?.id) continue;
+    const prev = map.get(raw.id);
+    map.set(raw.id, { ...prev ?? raw, ...raw });
+  }
+  return [...map.values()];
+}
+function mergeGroups(current, incoming) {
+  if (!incoming?.length) {
+    return current.map((g) => ({ ...g, layerIds: [...g.layerIds ?? []] }));
+  }
+  const map = new Map(
+    current.map((g) => [g.id, { ...g, layerIds: [...g.layerIds ?? []] }])
+  );
+  for (const raw of incoming) {
+    if (!raw?.id) continue;
+    map.set(raw.id, {
+      id: raw.id,
+      name: raw.name ?? map.get(raw.id)?.name,
+      layerIds: [...raw.layerIds ?? map.get(raw.id)?.layerIds ?? []]
+    });
+  }
+  return [...map.values()];
+}
+function mergeLayerBridgePreset(current, partial) {
+  return {
+    ...current,
+    ...partial,
+    pages: upsertById(current.pages, partial.pages),
+    layers: mergeLayers(current.layers, partial.layers),
+    groups: mergeGroups(current.groups, partial.groups)
+  };
+}
+
+// src/resolve-pane-sync-groups.ts
+function resolvePaneSyncId(layer) {
+  if (layer == null) return void 0;
+  const raw = layer.syncTimeScaleGroupId;
+  if (raw == null) return null;
+  const trimmed = String(raw).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolvePaneSyncGroupsFromLayers(layers, pageId) {
+  const scoped = pageId != null ? layers.filter((l) => l.pageId === pageId) : layers;
+  const pick = (type) => scoped.find((l) => l.type === type);
+  return {
+    main: resolvePaneSyncId(pick("chart.main")),
+    volume: resolvePaneSyncId(pick("chart.volume")),
+    indicator: resolvePaneSyncId(pick("chart.indicator"))
+  };
+}
+
+// src/bridge-layer-wire.ts
+var PANE_LAYER_TYPES = {
+  main: "chart.main",
+  volume: "chart.volume",
+  indicator: "chart.indicator"
+};
+var registry = /* @__PURE__ */ new Map();
+function registerChartLayerBridge(reg) {
+  const state = {
+    ...reg,
+    mergePreset: reg.mergePreset ?? mergeLayerBridgePreset,
+    visitedPageIds: /* @__PURE__ */ new Set(),
+    pendingAllPagesApply: false
+  };
+  registry.set(reg.chartId, state);
+  return () => {
+    registry.delete(reg.chartId);
+  };
+}
+function unregisterChartLayerBridge(chartId) {
+  registry.delete(chartId);
+}
+function clearLayerBridgeVisitedPages(chartId) {
+  const state = registry.get(chartId);
+  if (!state) return;
+  state.visitedPageIds.clear();
+  state.pendingAllPagesApply = false;
+}
+function hasLayerBridgeRegistration(chartId) {
+  if (chartId != null) return registry.has(chartId);
+  return registry.size > 0;
+}
+function isValidLayerBridgePane(pane) {
+  return pane === "main" || pane === "volume" || pane === "indicator";
+}
+function resolvePaneLayerIds(preset, pane, opts) {
+  const layerType = PANE_LAYER_TYPES[pane];
+  const allPages = opts?.allPages === true;
+  const activePageId = opts?.activePageId;
+  const pageIds = allPages ? preset.pages.map((p) => p.id) : activePageId ? [activePageId] : [];
+  if (pageIds.length === 0) return [];
+  return preset.layers.filter((l) => pageIds.includes(l.pageId) && l.type === layerType).map((l) => l.id);
+}
+function postLayerError(chartId, code, message, post) {
+  post("chart.error", { chartId, code, message });
+}
+function applyTimeScaleForPage(state, pageId) {
+  state.chart.applyTimeScaleSyncFromLayers(state.layerController.getPreset().layers, pageId);
+  state.visitedPageIds.add(pageId);
+}
+function lazyApplyActivePage(state) {
+  applyTimeScaleForPage(state, state.layerController.activePageId);
+}
+function invalidateNonActivePageVisits(state) {
+  const activeId = state.layerController.activePageId;
+  for (const p of state.layerController.getPreset().pages) {
+    if (p.id !== activeId) state.visitedPageIds.delete(p.id);
+  }
+}
+function afterPresetMutation(state) {
+  state.compositorApply?.();
+  state.syncCompositorShellVisibility?.();
+  lazyApplyActivePage(state);
+}
+function requirePayloadChartId(payload) {
+  const id = typeof payload.chartId === "string" ? payload.chartId.trim() : "";
+  return id.length > 0 ? id : null;
+}
+function handleSetSyncGroup(state, payload, post, postError) {
+  if (bridgeLayerPayloadHasDeprecatedLayerId(payload)) {
+    postError("INVALID_PAYLOAD", "host.layer.setSyncGroup does not accept layerId (use pane)");
+    return;
+  }
+  if (!("pane" in payload)) {
+    postError("INVALID_PAYLOAD", "pane is required");
+    return;
+  }
+  if (!isValidLayerBridgePane(payload.pane)) {
+    postError("INVALID_PANE", `Invalid pane: ${String(payload.pane ?? "")}`);
+    return;
+  }
+  const pane = payload.pane;
+  const allPages = payload.allPages === true;
+  const groupId = payload.groupId == null ? "" : String(payload.groupId);
+  const preset = state.layerController.getPreset();
+  const layerIds = resolvePaneLayerIds(preset, pane, {
+    allPages,
+    activePageId: state.layerController.activePageId
+  });
+  if (layerIds.length === 0) {
+    postError("PANE_NOT_FOUND", `No ${pane} pane layers in scope`);
+    return;
+  }
+  for (const layerId of layerIds) {
+    state.layerController.setLayerSyncGroup(layerId, groupId);
+  }
+  lazyApplyActivePage(state);
+  post("chart.layerSyncGroupChanged", {
+    chartId: state.chartId,
+    pane,
+    groupId,
+    allPages,
+    activePageId: state.layerController.activePageId
+  });
+}
+function handleSetVisible(state, payload, post, postError) {
+  if (!("pane" in payload)) {
+    postError("INVALID_PAYLOAD", "pane is required");
+    return;
+  }
+  if (!isValidLayerBridgePane(payload.pane)) {
+    postError("INVALID_PANE", `Invalid pane: ${String(payload.pane ?? "")}`);
+    return;
+  }
+  if (typeof payload.visible !== "boolean") {
+    postError("INVALID_PAYLOAD", "visible must be boolean");
+    return;
+  }
+  const pane = payload.pane;
+  const allPages = payload.allPages === true;
+  const visible = payload.visible;
+  const preset = state.layerController.getPreset();
+  const layerIds = resolvePaneLayerIds(preset, pane, {
+    allPages,
+    activePageId: state.layerController.activePageId
+  });
+  if (layerIds.length === 0) {
+    postError("PANE_NOT_FOUND", `No ${pane} pane layers in scope`);
+    return;
+  }
+  for (const layerId of layerIds) {
+    state.layerController.setLayerVisible(layerId, visible);
+  }
+  state.compositorApply?.();
+  state.syncCompositorShellVisibility?.();
+  post("chart.layerVisibleChanged", {
+    chartId: state.chartId,
+    pane,
+    visible,
+    allPages
+  });
+}
+function maybeClearPendingAllPages(state) {
+  if (!state.pendingAllPagesApply) return;
+  const allVisited = state.layerController.getPreset().pages.every((p) => state.visitedPageIds.has(p.id));
+  if (allVisited) state.pendingAllPagesApply = false;
+}
+function handleSetActivePage(state, payload, post, postError) {
+  const pageId = typeof payload.pageId === "string" ? payload.pageId : "";
+  if (!pageId) {
+    postError("INVALID_PAYLOAD", "pageId is required");
+    return;
+  }
+  const preset = state.layerController.getPreset();
+  if (!preset.pages.some((p) => p.id === pageId)) {
+    postError("INVALID_PAYLOAD", `Unknown pageId: ${pageId}`);
+    return;
+  }
+  const previousPageId = state.layerController.activePageId;
+  if (previousPageId === pageId) {
+    return;
+  }
+  if (!state.layerController.setActivePage(pageId)) {
+    return;
+  }
+  state.compositorApply?.();
+  state.syncCompositorShellVisibility?.();
+  if (!state.visitedPageIds.has(pageId) || state.pendingAllPagesApply) {
+    applyTimeScaleForPage(state, pageId);
+  }
+  maybeClearPendingAllPages(state);
+  post("chart.layerPageChanged", {
+    chartId: state.chartId,
+    pageId,
+    previousPageId
+  });
+}
+function handleSetPreset(state, payload, postError, emitLayerDeltas) {
+  const rawPreset = payload.preset;
+  if (!rawPreset || typeof rawPreset !== "object") {
+    postError("INVALID_PRESET", "preset object is required");
+    return;
+  }
+  const incoming = rawPreset;
+  const revisionRaw = Number(incoming.revision);
+  if (!Number.isFinite(revisionRaw) || revisionRaw < 1) {
+    postError("INVALID_PRESET", "preset.revision must be an integer \u2265 1");
+    return;
+  }
+  const revision = Math.floor(revisionRaw);
+  if (revision < state.layerController.presetRevision) {
+    postError(
+      "STALE_PRESET_REVISION",
+      `Host revision ${revision} < current ${state.layerController.presetRevision}`
+    );
+    return;
+  }
+  const replace = payload.replace === true;
+  const normalize = state.normalizePreset ?? ((p) => p);
+  const mergeFn = state.mergePreset ?? mergeLayerBridgePreset;
+  const current = state.layerController.getPreset();
+  let merged;
+  try {
+    merged = replace ? normalize({ ...incoming, revision }) : normalize(mergeFn(current, { ...incoming, revision }));
+  } catch (err) {
+    postError("INVALID_PRESET", err instanceof Error ? err.message : String(err));
+    return;
+  }
+  const prev = state.layerController.getPreset();
+  if (!state.layerController.setPreset(merged)) {
+    postError("INVALID_PRESET", "setPreset rejected (interaction in progress)");
+    return;
+  }
+  state.layerController.presetRevision = revision;
+  afterPresetMutation(state);
+  emitLayerDeltas(prev, state.layerController.getPreset());
+}
+function handleApplyTimeScaleSync(state, payload, postError) {
+  const allPages = payload.allPages === true;
+  const activeId = state.layerController.activePageId;
+  const pageId = typeof payload.pageId === "string" ? payload.pageId : activeId;
+  if (!state.layerController.getPreset().pages.some((p) => p.id === pageId)) {
+    postError("INVALID_PAYLOAD", `Unknown pageId: ${pageId}`);
+    return;
+  }
+  if (allPages) {
+    state.pendingAllPagesApply = true;
+    invalidateNonActivePageVisits(state);
+    applyTimeScaleForPage(state, activeId);
+    return;
+  }
+  if (pageId === activeId) {
+    applyTimeScaleForPage(state, pageId);
+  } else {
+    state.visitedPageIds.delete(pageId);
+  }
+}
+function emitPresetLayerDeltas(state, prev, next, postSync, postVisible, _postPage) {
+  const active = state.layerController.activePageId;
+  for (const pane of ["main", "volume", "indicator"]) {
+    const prevIds = resolvePaneLayerIds(prev, pane, { activePageId: active });
+    const nextIds = resolvePaneLayerIds(next, pane, { activePageId: active });
+    if (prevIds.length === 0 && nextIds.length === 0) continue;
+    const prevLayer = prev.layers.find((l) => l.id === prevIds[0]);
+    const nextLayer = next.layers.find((l) => l.id === nextIds[0]);
+    const prevGroup = prevLayer?.syncTimeScaleGroupId ?? "";
+    const nextGroup = nextLayer?.syncTimeScaleGroupId ?? "";
+    if (prevGroup !== nextGroup && nextIds.length > 0) {
+      postSync("chart.layerSyncGroupChanged", {
+        chartId: state.chartId,
+        pane,
+        groupId: nextGroup,
+        allPages: false,
+        activePageId: active
+      });
+    }
+    if (prevLayer && nextLayer && prevLayer.visible !== nextLayer.visible) {
+      postVisible("chart.layerVisibleChanged", {
+        chartId: state.chartId,
+        pane,
+        visible: nextLayer.visible !== false,
+        allPages: false
+      });
+    }
+  }
+}
+function handleLayerBridgeMessage(type, payload, opts) {
+  if (!isBridgeLayerInboundType(type)) return false;
+  const chartId = requirePayloadChartId(payload);
+  if (!chartId) {
+    opts.post("chart.error", {
+      chartId: "",
+      code: "MISSING_CHART_ID",
+      message: "chartId is required in payload for host.layer.*"
+    });
+    return true;
+  }
+  const state = registry.get(chartId);
+  if (!state) {
+    const code = registry.size === 0 ? "LAYER_BRIDGE_NOT_REGISTERED" : "CHART_NOT_FOUND";
+    const message = code === "LAYER_BRIDGE_NOT_REGISTERED" ? "Layer bridge is not registered (pass layerBridge to wireChartBridge)" : `No layer bridge registered for chartId: ${chartId}`;
+    opts.post("chart.error", { chartId, code, message });
+    return true;
+  }
+  const postError = (code, message) => postLayerError(chartId, code, message, opts.post);
+  const postSync = (_type, payload2) => opts.post("chart.layerSyncGroupChanged", payload2);
+  const postVisible = (_type, payload2) => opts.post("chart.layerVisibleChanged", payload2);
+  const postPage = (_type, payload2) => opts.post("chart.layerPageChanged", payload2);
+  switch (type) {
+    case "host.layer.setSyncGroup":
+      handleSetSyncGroup(state, payload, postSync, postError);
+      break;
+    case "host.layer.setVisible":
+      handleSetVisible(state, payload, postVisible, postError);
+      break;
+    case "host.layer.setActivePage":
+      handleSetActivePage(state, payload, postPage, postError);
+      break;
+    case "host.layer.setPreset":
+      handleSetPreset(
+        state,
+        payload,
+        postError,
+        (prev, next) => emitPresetLayerDeltas(state, prev, next, postSync, postVisible, postPage)
+      );
+      break;
+    case "host.layer.applyTimeScaleSync":
+      handleApplyTimeScaleSync(state, payload, postError);
+      break;
+    default:
+      postError("SCHEMA_MISMATCH", `Unknown host.layer.* event: ${type}`);
+  }
+  return true;
+}
+function resolvePaneSyncGroupsForBridge(layers, pageId) {
+  return resolvePaneSyncGroupsFromLayers(layers, pageId);
+}
+
 // src/version.ts
-var TRADVIEW_VERSION = "1.0.2";
+var TRADVIEW_VERSION = "1.1.0";
 
 // src/bridge-wire.ts
 var TRADVIEW_API_VERSION = 1;
+var DRAWING_TOOLS = /* @__PURE__ */ new Set([
+  "cursor",
+  "trendline",
+  "hline",
+  "vline",
+  "rectangle",
+  "fibonacci",
+  "text"
+]);
 var CHART_EVENT_TO_BRIDGE = {
   connectionChange: "chart.connectionChange",
   visibleRangeChange: "chart.visibleRange",
@@ -32,7 +432,8 @@ function wireChartBridge(opts) {
     chartId,
     bridgeSchemaVersion: BRIDGE_SCHEMA_VERSION,
     apiVersion: TRADVIEW_API_VERSION,
-    version: TRADVIEW_VERSION
+    version: TRADVIEW_VERSION,
+    layerApi: LAYER_API_READY
   });
   const postResize = () => {
     const el = controller.getContainer();
@@ -115,15 +516,37 @@ function wireChartBridge(opts) {
       chart.on(ev, fn);
     }
   }
+  const unregisterLayer = opts.layerBridge ? registerChartLayerBridge({ ...opts.layerBridge, chartId }) : void 0;
   const offHost = bridge.onMessage((msg) => {
     if (!isBridgeInbound(msg)) return;
     const p = msg.payload ?? {};
+    if (msg.type.startsWith("host.layer.")) {
+      if (!isBridgeLayerInboundType2(msg.type)) {
+        post("chart.error", {
+          chartId: typeof p.chartId === "string" ? p.chartId : "",
+          code: "SCHEMA_MISMATCH",
+          message: `Unknown host.layer.* event: ${msg.type}`
+        });
+        return;
+      }
+      handleLayerBridgeMessage(msg.type, p, {
+        bridge,
+        post: (type, payload) => post(type, payload)
+      });
+      return;
+    }
     switch (msg.type) {
       case "host.setSymbol":
-        if (typeof p.symbol === "string") chart.setSymbol(p.symbol);
+        if (typeof p.symbol === "string") {
+          chart.setSymbol(p.symbol);
+          clearLayerBridgeVisitedPages(chartId);
+        }
         break;
       case "host.setInterval":
-        if (typeof p.interval === "string") chart.setInterval(p.interval);
+        if (typeof p.interval === "string") {
+          chart.setInterval(p.interval);
+          clearLayerBridgeVisitedPages(chartId);
+        }
         break;
       case "host.setTheme":
         if (p.theme === "dark" || p.theme === "light") chart.setTheme(p.theme);
@@ -174,6 +597,33 @@ function wireChartBridge(opts) {
           chart.setFeatures(p.features);
         }
         break;
+      case "host.setIndicatorConfig":
+        if (p.config && typeof p.config === "object") {
+          chart.setIndicatorConfig(p.config);
+        }
+        break;
+      case "host.clearAllIndicators":
+        chart.clearAllIndicators();
+        break;
+      case "host.clearAllDrawings":
+        chart.clearAllDrawings();
+        break;
+      case "host.setDrawingTool":
+        if (typeof p.tool === "string" && DRAWING_TOOLS.has(p.tool)) {
+          chart.setDrawingTool(p.tool);
+        }
+        break;
+      case "host.setChartPaneResizeFocus":
+        if (p.pane === "main" || p.pane === "volume" || p.pane === "indicator" || p.pane === "all") {
+          chart.setChartPaneResizeFocus(p.pane);
+        } else {
+          post("chart.error", {
+            chartId,
+            code: "INVALID_PANE",
+            message: `Invalid pane: ${String(p.pane ?? "")}`
+          });
+        }
+        break;
       case "host.destroy":
         chart.destroy();
         break;
@@ -184,11 +634,17 @@ function wireChartBridge(opts) {
   return () => {
     if (crosshairTimer) clearTimeout(crosshairTimer);
     offHost();
+    unregisterLayer?.();
     for (const [ev, fn] of handlers) chart.off(ev, fn);
   };
 }
 
 // src/chart-controller.ts
+import {
+  clearedIndicatorConfig,
+  disableIndicatorLayer as applyDisableIndicatorLayer,
+  listActiveIndicatorLayers
+} from "@coderyo/indicators";
 import { floorBarOpenTime, intervalMs as intervalMs2 } from "@coderyo/data";
 import { parseInterval } from "@coderyo/data";
 import { BarStore, computeGapStartTimes, TickAggregator } from "@coderyo/series";
@@ -234,7 +690,9 @@ import {
   runPineLiteAsync,
   terminatePineWorker
 } from "@coderyo/pine-lite";
-import { PaneOrchestrator } from "@coderyo/renderer-lite";
+import {
+  PaneOrchestrator
+} from "@coderyo/renderer-lite";
 
 // src/chart-features.ts
 var DEFAULT_CHART_FEATURES = {
@@ -251,7 +709,9 @@ var DEFAULT_CHART_FEATURES = {
   protobuf: false,
   telemetry: false,
   tickStream: false,
-  pineWorker: true
+  pineWorker: true,
+  autoBarSpacingOnInterval: true,
+  barSpacingByInterval: void 0
 };
 function resolveChartFeatures(partial) {
   const d = DEFAULT_CHART_FEATURES;
@@ -275,7 +735,9 @@ function resolveChartFeatures(partial) {
     protobuf: partial?.protobuf ?? d.protobuf,
     telemetry: partial?.telemetry ?? d.telemetry,
     tickStream: partial?.tickStream ?? d.tickStream,
-    pineWorker: partial?.pineWorker ?? d.pineWorker
+    pineWorker: partial?.pineWorker ?? d.pineWorker,
+    autoBarSpacingOnInterval: partial?.autoBarSpacingOnInterval ?? d.autoBarSpacingOnInterval,
+    barSpacingByInterval: partial?.barSpacingByInterval ?? d.barSpacingByInterval
   };
 }
 function mergeChartFeatures(current, patch) {
@@ -293,16 +755,58 @@ function mergeChartFeatures(current, patch) {
     protobuf: patch.protobuf ?? current.protobuf,
     telemetry: patch.telemetry ?? current.telemetry,
     tickStream: patch.tickStream ?? current.tickStream,
-    pineWorker: patch.pineWorker ?? current.pineWorker
+    pineWorker: patch.pineWorker ?? current.pineWorker,
+    autoBarSpacingOnInterval: patch.autoBarSpacingOnInterval ?? current.autoBarSpacingOnInterval,
+    barSpacingByInterval: patch.barSpacingByInterval ?? current.barSpacingByInterval
   });
 }
 var PENDING_SYMBOL = "";
 
+// src/indicator-storage.ts
+import {
+  DEFAULT_INDICATOR_CONFIG,
+  indicatorConfigStorageKey
+} from "@coderyo/indicators";
+function createLocalChartStorage() {
+  return {
+    getItem: (key) => {
+      try {
+        return localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    setItem: (key, value) => {
+      try {
+        localStorage.setItem(key, value);
+      } catch {
+      }
+    }
+  };
+}
+var defaultChartStorage = createLocalChartStorage();
+function loadIndicatorConfig(storage, symbol, interval) {
+  try {
+    const raw = storage.getItem(indicatorConfigStorageKey(symbol, interval));
+    if (!raw) return { ...DEFAULT_INDICATOR_CONFIG };
+    return { ...DEFAULT_INDICATOR_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_INDICATOR_CONFIG };
+  }
+}
+function saveIndicatorConfig(storage, symbol, interval, config) {
+  try {
+    storage.setItem(indicatorConfigStorageKey(symbol, interval), JSON.stringify(config));
+  } catch {
+  }
+}
+
 // src/chart-controller.ts
 var ChartController = class {
   constructor(container, options) {
     this.container = container;
     this.options = options;
+    this.chartStorage = options.chartStorage ?? defaultChartStorage;
     this.features = resolveChartFeatures({
       ...options.features,
       fetchPolicy: options.features?.fetchPolicy ?? options.fetchPolicy,
@@ -310,36 +814,48 @@ var ChartController = class {
     });
     const symbol = options.symbol?.trim() || PENDING_SYMBOL;
     const interval = parseInterval(options.interval ?? "1h");
-    const fetchPolicy = this.features.gaps.fillVisibleHoles ? "fill-visible-holes" : this.features.fetchPolicy;
+    this.fetchPolicy = this.features.gaps.fillVisibleHoles ? "fill-visible-holes" : this.features.fetchPolicy;
     this.store = new BarStore(symbol || PENDING_SYMBOL, interval);
-    this.virtualWindow = new VirtualWindow(this.store, { fetchPolicy });
     this.orchestrator = new PaneOrchestrator({
       container,
+      volumeMount: options.volumeMount,
+      listenPaneResizeEvents: false,
       indicatorRoot: options.indicatorHost,
       theme: options.theme ?? "dark",
       scaleMode: options.scaleMode ?? "linear",
       showGrid: options.showGrid ?? false,
       indicatorConfig: this.features.indicators,
       smoothPriceUpdate: this.features.smoothPriceUpdate,
-      smoothPriceDurationMs: this.features.smoothPriceDurationMs
+      smoothPriceDurationMs: this.features.smoothPriceDurationMs,
+      onIndicatorConfigChange: (config) => this.setIndicatorConfig(config),
+      autoBarSpacingOnInterval: this.features.autoBarSpacingOnInterval,
+      barSpacingByInterval: this.features.barSpacingByInterval
     });
+    this.orchestrator.setIntervalContext(interval);
     if (options.width) container.style.width = `${options.width}px`;
     if (options.height) container.style.height = `${options.height}px`;
     this.resizeObserver = new ResizeObserver(() => {
-      if (!this.destroyed) this.resize();
+      if (this.destroyed) return;
+      this.orchestrator.setResizeFocusPanes(null);
     });
-    this.resizeObserver.observe(container);
-    this.orchestrator.bus.subscribeTransform(() => {
-      const bus = this.orchestrator.bus;
-      if (bus.visibleToMs > bus.visibleFromMs) {
-        this.virtualWindow.setVisibleRange({
-          fromMs: bus.visibleFromMs,
-          toMs: bus.visibleToMs
-        });
-        this.visibleRangeInitialized = true;
-      }
-      void this.maybeLoadMore();
-      this.drawingManager?.redraw();
+    const resizeTargets = [container, options.volumeMount, options.indicatorHost].filter(
+      Boolean
+    );
+    for (const el of resizeTargets) this.resizeObserver.observe(el);
+    window.addEventListener("tradview:pane-resize", this.onPaneResize);
+    this.orchestrator.busRegistry.forEachBus((key, bus) => {
+      bus.subscribeTransform(() => {
+        if (key !== this.orchestrator.busRegistry.getActiveBusKey()) return;
+        if (bus.visibleToMs > bus.visibleFromMs) {
+          this.activeVirtualWindow().setVisibleRange({
+            fromMs: bus.visibleFromMs,
+            toMs: bus.visibleToMs
+          });
+          this.visibleRangeInitialized = true;
+        }
+        void this.maybeLoadMore();
+        this.drawingManager?.redraw();
+      });
     });
     const overlay = this.orchestrator.getOverlayCanvas();
     if (overlay) {
@@ -366,6 +882,7 @@ var ChartController = class {
       this.emit("crosshairChange", payload);
     });
     this.bindPageResumeCatchUp();
+    this.applyPersistedIndicatorsOnInit(options);
     if (this.hasActiveSymbol()) {
       void this.bootstrap(this.loadGeneration);
     } else {
@@ -375,7 +892,9 @@ var ChartController = class {
   container;
   options;
   store;
-  virtualWindow;
+  fetchPolicy;
+  /** Per sync-group viewport for loadMore / render slicing (active bus drives IChart APIs). */
+  virtualWindows = /* @__PURE__ */ new Map();
   orchestrator;
   handlers = /* @__PURE__ */ new Map();
   subscriptionId = null;
@@ -393,10 +912,20 @@ var ChartController = class {
   catchUpInFlight = false;
   lastCatchUpAt = 0;
   offPageResume = null;
+  /** After clearAllIndicators(); blocks Pine replot until script/features change. */
+  pinePlotsSuppressed = false;
+  chartStorage;
+  onPaneResize = () => {
+    if (this.destroyed) return;
+    this.orchestrator.setResizeFocusPanes(null);
+  };
   getFeatures() {
     return { ...this.features };
   }
   setFeatures(patch) {
+    if (patch.pineEnabled === true || patch.pineScript !== void 0) {
+      this.pinePlotsSuppressed = false;
+    }
     this.features = mergeChartFeatures(this.features, patch);
     this.applyFeatures();
     this.emit("featuresChange", this.getFeatures());
@@ -406,10 +935,26 @@ var ChartController = class {
     const s = this.store.symbol;
     return s.length > 0 && s !== PENDING_SYMBOL;
   }
+  activeVirtualWindow() {
+    const key = this.orchestrator.busRegistry.getActiveBusKey();
+    let vw = this.virtualWindows.get(key);
+    if (!vw) {
+      vw = new VirtualWindow(this.store, { fetchPolicy: this.fetchPolicy });
+      const range = this.orchestrator.busRegistry.getOrCreateBus(key).getVisibleRange();
+      if (range) vw.setVisibleRange(range);
+      this.virtualWindows.set(key, vw);
+    }
+    return vw;
+  }
   applyFeatures() {
     const fetchPolicy = this.features.gaps.fillVisibleHoles ? "fill-visible-holes" : this.features.fetchPolicy;
-    this.virtualWindow.setFetchPolicy(fetchPolicy);
+    this.fetchPolicy = fetchPolicy;
+    for (const vw of this.virtualWindows.values()) vw.setFetchPolicy(fetchPolicy);
     this.orchestrator.setIndicatorConfig(this.features.indicators);
+    this.orchestrator.setBarSpacingPolicy({
+      autoBarSpacingOnInterval: this.features.autoBarSpacingOnInterval,
+      barSpacingByInterval: this.features.barSpacingByInterval
+    });
     this.orchestrator.setSmoothPriceUpdate(
       this.features.smoothPriceUpdate,
       this.features.smoothPriceDurationMs
@@ -433,12 +978,12 @@ var ChartController = class {
     }
     this.pineIr = compiled.ir;
     if (this.hasActiveSymbol()) {
-      const bars = this.virtualWindow.getBarsForRender();
+      const bars = this.activeVirtualWindow().getBarsForRender();
       if (bars.length > 0) this.applyPinePlots(bars);
     }
   }
   applyPinePlots(bars) {
-    if (!this.features.pineEnabled || !this.pineIr) {
+    if (this.pinePlotsSuppressed || !this.features.pineEnabled || !this.pineIr) {
       this.orchestrator.setPinePlots(null);
       return;
     }
@@ -503,7 +1048,7 @@ var ChartController = class {
   async applyRealtimeBar(bar, partial, loadGen = this.loadGeneration) {
     await this.store.mergeRealtime({ bar, partial });
     if (!this.isLoadGenerationCurrent(loadGen)) return;
-    const bars = this.virtualWindow.getBarsForRender();
+    const bars = this.activeVirtualWindow().getBarsForRender();
     const last = bars[bars.length - 1];
     if (last && this.features.smoothPriceUpdate) {
       this.orchestrator.updateLastBar(last, {
@@ -570,6 +1115,21 @@ var ChartController = class {
     this.orchestrator.resize();
     return this;
   }
+  /** P2: limit LWC resize to focused panes; also selects that pane's time-scale sync group for IChart APIs. */
+  setChartPaneResizeFocus(pane) {
+    if (pane !== "all") {
+      this.orchestrator.setActiveSyncPane(pane);
+      this.orchestrator.setResizeFocusPanes([pane]);
+    } else {
+      this.orchestrator.setResizeFocusPanes(null);
+    }
+    return this;
+  }
+  /** Apply `syncTimeScaleGroupId` from layout layers to pane buses (empty = independent). */
+  applyTimeScaleSyncFromLayers(layers, pageId) {
+    this.orchestrator.setPaneSyncGroups(resolvePaneSyncGroupsFromLayers(layers, pageId));
+    return this;
+  }
   setDrawingTool(tool) {
     this.drawingManager?.setTool(tool);
     this.syncOverlayPointerEvents();
@@ -593,27 +1153,80 @@ var ChartController = class {
   setIndicatorConfig(config) {
     this.features = mergeChartFeatures(this.features, { indicators: config });
     this.orchestrator.setIndicatorConfig(config);
+    if (config && this.features.indicatorPersist && this.hasActiveSymbol()) {
+      saveIndicatorConfig(
+        this.chartStorage,
+        this.store.symbol,
+        this.store.interval,
+        config
+      );
+    }
+    this.emit("featuresChange", this.getFeatures());
+  }
+  applyPersistedIndicatorsOnInit(options) {
+    if (!this.features.indicatorPersist || !this.hasActiveSymbol()) return;
+    const explicit = options.features?.indicators !== void 0 || options.indicatorConfig !== void 0;
+    if (explicit) return;
+    this.applyPersistedIndicatorsForContext();
+  }
+  applyPersistedIndicatorsForContext() {
+    if (!this.features.indicatorPersist || !this.hasActiveSymbol()) return;
+    const loaded = loadIndicatorConfig(
+      this.chartStorage,
+      this.store.symbol,
+      this.store.interval
+    );
+    this.features = mergeChartFeatures(this.features, { indicators: loaded });
+    this.orchestrator.setIndicatorConfig(loaded);
     this.emit("featuresChange", this.getFeatures());
   }
+  /** @public List built-in indicator layers currently enabled on the chart. */
+  listIndicatorLayers() {
+    if (this.features.indicators === null) return [];
+    return listActiveIndicatorLayers(this.features.indicators);
+  }
+  /** @public Disable a single built-in indicator layer by id. */
+  disableIndicatorLayer(id) {
+    if (this.features.indicators === null) {
+      return clearedIndicatorConfig();
+    }
+    const next = applyDisableIndicatorLayer(this.features.indicators, id);
+    this.setIndicatorConfig(next);
+    return next;
+  }
+  clearAllIndicators() {
+    const config = clearedIndicatorConfig(this.features.indicators ?? void 0);
+    this.setIndicatorConfig(config);
+    this.orchestrator.setPinePlots(null);
+    this.pinePlotsSuppressed = true;
+    return config;
+  }
+  clearAllDrawings() {
+    return this.drawingManager?.clearAll() ?? 0;
+  }
   setReturnToCursorAfterDraw(v) {
     this.drawingManager?.setReturnToCursorAfterDraw(v);
   }
   async setSymbol(symbol) {
     const trimmed = symbol.trim();
     if (!trimmed) return;
+    this.orchestrator.setIntervalContext(this.store.interval);
     const gen = this.beginDataContextChange();
     await this.teardownSubscription();
     await this.store.setSymbolInterval(trimmed, this.store.interval);
     this.drawingManager?.setContext(symbol, this.store.interval);
+    this.applyPersistedIndicatorsForContext();
     const info = await this.resolveSymbol(symbol);
     await this.bootstrap(gen);
     this.emit("symbolChange", info ?? { symbol });
   }
   async setInterval(interval) {
+    this.orchestrator.setIntervalContext(interval);
     const gen = this.beginDataContextChange();
     await this.teardownSubscription();
     await this.store.setSymbolInterval(this.store.symbol, interval);
     this.drawingManager?.setContext(this.store.symbol, interval);
+    this.applyPersistedIndicatorsForContext();
     if (this.hasActiveSymbol()) {
       await this.bootstrap(gen);
     }
@@ -648,7 +1261,7 @@ var ChartController = class {
     this.orchestrator.setVisibleRange(range);
     const { fromMs, toMs } = range;
     if (toMs > fromMs) {
-      this.virtualWindow.setVisibleRange({ fromMs, toMs });
+      this.activeVirtualWindow().setVisibleRange({ fromMs, toMs });
       this.visibleRangeInitialized = true;
     }
     return this;
@@ -720,6 +1333,7 @@ var ChartController = class {
     this.offCrosshair?.();
     this.offCrosshair = null;
     this.resizeObserver.disconnect();
+    window.removeEventListener("tradview:pane-resize", this.onPaneResize);
     this.drawingManager?.destroy();
     void this.teardownSubscription();
     this.orchestrator.destroy();
@@ -730,7 +1344,7 @@ var ChartController = class {
   beginDataContextChange() {
     this.loadGeneration += 1;
     this.visibleRangeInitialized = false;
-    this.virtualWindow.setVisibleRange({ fromMs: 0, toMs: 0 });
+    this.virtualWindows.clear();
     this.orchestrator.resetViewState();
     this.orchestrator.clearBars();
     return this.loadGeneration;
@@ -742,74 +1356,86 @@ var ChartController = class {
     if (!this.isLoadGenerationCurrent(loadGen)) return;
     const symbol = this.store.symbol;
     const interval = this.store.interval;
-    const endTime = Date.now();
-    if (this.features.protobuf) {
-      this.emit("error", {
-        code: "PROTOBUF_UNAVAILABLE",
-        message: "Protobuf encoding requires protocol v1.1 (not in 1.0.0)"
+    try {
+      const endTime = Date.now();
+      if (this.features.protobuf) {
+        this.emit("error", {
+          code: "PROTOBUF_UNAVAILABLE",
+          message: "Protobuf encoding requires protocol v1.1 (not in 1.0.0)"
+        });
+      }
+      const history = await fetchChartHistory(this.options.dataProvider, {
+        mode: "loadMore",
+        symbol,
+        interval,
+        endTime,
+        limit: 500
       });
-    }
-    const history = await fetchChartHistory(this.options.dataProvider, {
-      mode: "loadMore",
-      symbol,
-      interval,
-      endTime,
-      limit: 500
-    });
-    if (!this.isLoadGenerationCurrent(loadGen)) return;
-    if (this.store.symbol !== symbol || this.store.interval !== interval) return;
-    await this.store.mergeBars(history.bars.map((bar) => ({ bar })));
-    if (!this.isLoadGenerationCurrent(loadGen)) return;
-    this.refreshRender(loadGen);
-    void this.resolveSymbol(symbol).then((info) => {
-      if (!this.isLoadGenerationCurrent(loadGen)) return;
-      this.emit("symbolChange", info ?? { symbol });
-    });
-    this.emit("intervalChange", interval);
-    const streamMode = this.features.tickStream ? "bar+tick" : this.features.streamMode;
-    const tickOnly = streamMode === "tick";
-    const params = {
-      symbol,
-      interval,
-      channels: tickOnly ? ["tick"] : this.features.tickStream ? ["bar", "tick"] : ["bar"],
-      streamMode
-    };
-    this.tickAggregator = tickOnly ? new TickAggregator(interval, (bar, partial) => {
       if (!this.isLoadGenerationCurrent(loadGen)) return;
       if (this.store.symbol !== symbol || this.store.interval !== interval) return;
-      void this.applyRealtimeBar(bar, partial, loadGen);
-    }) : null;
-    await this.options.dataProvider.connect?.();
-    if (!this.isLoadGenerationCurrent(loadGen)) return;
-    const sub = await this.options.dataProvider.subscribe(params, {
-      onBar: tickOnly ? void 0 : (bar, meta) => {
+      if (history.bars.length === 0) {
+        this.emit("error", {
+          kind: "history",
+          message: `No bars returned for ${symbol} (${interval})`
+        });
+        return;
+      }
+      await this.store.mergeBars(history.bars.map((bar) => ({ bar })));
+      if (!this.isLoadGenerationCurrent(loadGen)) return;
+      this.refreshRender(loadGen);
+      void this.resolveSymbol(symbol).then((info) => {
         if (!this.isLoadGenerationCurrent(loadGen)) return;
-        if (this.store.symbol !== symbol || this.store.interval !== interval) return;
-        void this.applyRealtimeBar(bar, meta.partial, loadGen);
-      },
-      onTick: (tick) => {
+        this.emit("symbolChange", info ?? { symbol });
+      });
+      this.emit("intervalChange", interval);
+      const streamMode = this.features.tickStream ? "bar+tick" : this.features.streamMode;
+      const tickOnly = streamMode === "tick";
+      const params = {
+        symbol,
+        interval,
+        channels: tickOnly ? ["tick"] : this.features.tickStream ? ["bar", "tick"] : ["bar"],
+        streamMode
+      };
+      this.tickAggregator = tickOnly ? new TickAggregator(interval, (bar, partial) => {
         if (!this.isLoadGenerationCurrent(loadGen)) return;
         if (this.store.symbol !== symbol || this.store.interval !== interval) return;
-        if (this.tickAggregator) {
-          this.tickAggregator.ingest(tick);
-          return;
-        }
-        const bar = this.buildBarFromPrice(tick.price, tick.t);
-        void this.applyRealtimeBar(bar, true, loadGen);
-      },
-      onConnectionChange: (state) => {
-        this.emit("connectionChange", state);
-        if (state === "connected" && this.subscriptionId != null) {
-          void this.catchUpMissedBars();
-        }
-      },
-      onError: (err) => this.emit("error", err)
-    });
-    if (!this.isLoadGenerationCurrent(loadGen)) {
-      await this.options.dataProvider.unsubscribe(sub.id);
-      return;
+        void this.applyRealtimeBar(bar, partial, loadGen);
+      }) : null;
+      await this.options.dataProvider.connect?.();
+      if (!this.isLoadGenerationCurrent(loadGen)) return;
+      const sub = await this.options.dataProvider.subscribe(params, {
+        onBar: tickOnly ? void 0 : (bar, meta) => {
+          if (!this.isLoadGenerationCurrent(loadGen)) return;
+          if (this.store.symbol !== symbol || this.store.interval !== interval) return;
+          void this.applyRealtimeBar(bar, meta.partial, loadGen);
+        },
+        onTick: (tick) => {
+          if (!this.isLoadGenerationCurrent(loadGen)) return;
+          if (this.store.symbol !== symbol || this.store.interval !== interval) return;
+          if (this.tickAggregator) {
+            this.tickAggregator.ingest(tick);
+            return;
+          }
+          const bar = this.buildBarFromPrice(tick.price, tick.t);
+          void this.applyRealtimeBar(bar, true, loadGen);
+        },
+        onConnectionChange: (state) => {
+          this.emit("connectionChange", state);
+          if (state === "connected" && this.subscriptionId != null) {
+            void this.catchUpMissedBars();
+          }
+        },
+        onError: (err) => this.emit("error", err)
+      });
+      if (!this.isLoadGenerationCurrent(loadGen)) {
+        await this.options.dataProvider.unsubscribe(sub.id);
+        return;
+      }
+      this.subscriptionId = sub.id;
+    } catch (err) {
+      this.emit("error", err);
+      this.emit("connectionChange", "disconnected");
     }
-    this.subscriptionId = sub.id;
   }
   async teardownSubscription() {
     this.tickAggregator?.flush();
@@ -882,7 +1508,7 @@ var ChartController = class {
   async maybeLoadMore() {
     if (this.destroyed || this.loadingMore) return;
     const loadGen = this.loadGeneration;
-    const reqs = this.virtualWindow.planFetches();
+    const reqs = this.activeVirtualWindow().planFetches();
     if (reqs.length === 0) return;
     this.loadingMore = true;
     try {
@@ -912,19 +1538,20 @@ var ChartController = class {
     const times = this.store.sortedTimes;
     if (times.length === 0) return;
     if (!this.visibleRangeInitialized) {
-      this.virtualWindow.setVisibleRange({
+      this.activeVirtualWindow().setVisibleRange({
         fromMs: times[0],
         toMs: times[times.length - 1]
       });
       this.visibleRangeInitialized = true;
     }
-    const bars = this.virtualWindow.getBarsForRender();
+    const bars = this.activeVirtualWindow().getBarsForRender();
     if (bars.length === 0) return;
     const gaps = this.features.gaps.whitespace ? computeGapStartTimes(
       bars.map((b) => b.t),
       this.store.interval
     ) : void 0;
     this.orchestrator.setBars(bars, gaps);
+    this.orchestrator.resizeAllPanes();
     this.applyPinePlots(bars);
     this.drawingManager?.redraw();
     this.emit("visibleRangeChange", {
@@ -956,7 +1583,7 @@ function toHistoryQuery(req) {
 }
 
 // src/demo-presets.ts
-import { DEFAULT_INDICATOR_CONFIG } from "@coderyo/indicators";
+import { DEFAULT_INDICATOR_CONFIG as DEFAULT_INDICATOR_CONFIG2 } from "@coderyo/indicators";
 import { PINE_SAMPLE_SCRIPT } from "@coderyo/pine-lite";
 function createDemoChartFeatures(opts) {
   return {
@@ -964,7 +1591,7 @@ function createDemoChartFeatures(opts) {
     streamMode: "bar+tick",
     gaps: { whitespace: false, fillVisibleHoles: false },
     drawings: { layer: true, persist: true },
-    indicators: opts.indicatorConfig ?? DEFAULT_INDICATOR_CONFIG,
+    indicators: opts.indicatorConfig ?? DEFAULT_INDICATOR_CONFIG2,
     indicatorPersist: true,
     smoothPriceUpdate: true,
     smoothPriceDurationMs: 150,
@@ -974,7 +1601,7 @@ function createDemoChartFeatures(opts) {
   };
 }
 function createDemoChartOptions(base) {
-  const indicatorConfig = base.indicatorConfig ?? DEFAULT_INDICATOR_CONFIG;
+  const indicatorConfig = base.indicatorConfig ?? DEFAULT_INDICATOR_CONFIG2;
   return {
     ...base,
     features: createDemoChartFeatures({
@@ -1039,6 +1666,14 @@ function wrap(controller, beforeDestroy) {
       controller.resize(s);
       return wrap(controller, beforeDestroy);
     },
+    setChartPaneResizeFocus: (pane) => {
+      controller.setChartPaneResizeFocus(pane);
+      return wrap(controller, beforeDestroy);
+    },
+    applyTimeScaleSyncFromLayers: (layers, pageId) => {
+      controller.applyTimeScaleSyncFromLayers(layers, pageId);
+      return wrap(controller, beforeDestroy);
+    },
     setFullscreen: (e) => {
       controller.setFullscreen(e);
       return wrap(controller, beforeDestroy);
@@ -1072,6 +1707,10 @@ function wrap(controller, beforeDestroy) {
       controller.setIndicatorConfig(c);
       return wrap(controller, beforeDestroy);
     },
+    listIndicatorLayers: () => controller.listIndicatorLayers(),
+    disableIndicatorLayer: (id) => controller.disableIndicatorLayer(id),
+    clearAllIndicators: () => controller.clearAllIndicators(),
+    clearAllDrawings: () => controller.clearAllDrawings(),
     setReturnToCursorAfterDraw: (v) => {
       controller.setReturnToCursorAfterDraw(v);
       return wrap(controller, beforeDestroy);
@@ -1110,13 +1749,24 @@ function createChart(target, options) {
       bridge: options.bridge,
       chartId: options.chartId,
       outboundEvents: options.bridgeOutboundEvents,
-      crosshairThrottleMs: options.bridgeCrosshairThrottleMs
+      crosshairThrottleMs: options.bridgeCrosshairThrottleMs,
+      layerBridge: options.layerBridge
     });
   }
   return chart;
 }
 
 // src/index.ts
+import {
+  DEFAULT_INDICATOR_CONFIG as DEFAULT_INDICATOR_CONFIG3,
+  clearedIndicatorConfig as clearedIndicatorConfig2,
+  hasVisibleIndicatorPanes,
+  hasMainChartOverlays,
+  hasAnyActiveIndicators,
+  indicatorConfigStorageKey as indicatorConfigStorageKey2,
+  listActiveIndicatorLayers as listActiveIndicatorLayers2,
+  disableIndicatorLayer
+} from "@coderyo/indicators";
 import {
   compilePineLite as compilePineLite2,
   runPineLite,
@@ -1126,17 +1776,39 @@ import {
 export {
   ChartController,
   DEFAULT_CHART_FEATURES,
+  DEFAULT_INDICATOR_CONFIG3 as DEFAULT_INDICATOR_CONFIG,
   PENDING_SYMBOL,
   PINE_EDITOR_DEFAULT,
   PINE_SAMPLE_SCRIPT2 as PINE_SAMPLE_SCRIPT,
   TRADVIEW_API_VERSION,
   TRADVIEW_VERSION,
+  clearLayerBridgeVisitedPages,
+  clearedIndicatorConfig2 as clearedIndicatorConfig,
   compilePineLite2 as compilePineLite,
   createChart,
   createDemoChartFeatures,
   createDemoChartOptions,
+  createLocalChartStorage,
+  defaultChartStorage,
+  disableIndicatorLayer,
+  handleLayerBridgeMessage,
+  hasAnyActiveIndicators,
+  hasLayerBridgeRegistration,
+  hasMainChartOverlays,
+  hasVisibleIndicatorPanes,
+  indicatorConfigStorageKey2 as indicatorConfigStorageKey,
+  isValidLayerBridgePane,
+  listActiveIndicatorLayers2 as listActiveIndicatorLayers,
+  loadIndicatorConfig,
+  mergeLayerBridgePreset,
+  registerChartLayerBridge,
   resolveChartFeatures,
+  resolvePaneLayerIds,
+  resolvePaneSyncGroupsForBridge,
+  resolvePaneSyncGroupsFromLayers,
   runPineLite,
+  saveIndicatorConfig,
+  unregisterChartLayerBridge,
   wireChartBridge
 };
 //# sourceMappingURL=index.js.map