@takazudo/zdtp 0.4.9 → 0.4.11

package/dist/{index-CGev6ZiI.js → index-C8GR1TU-.js}

@@ -1,7 +1,7 @@
 import { jsx as y, jsxs as K, Fragment as kt } from "preact/jsx-runtime";
 import { useEffect as P, useState as Y, useRef as O, useMemo as J, useCallback as X } from "preact/hooks";
-import { b as ft, p as wt, u as ht, a as Ne, A as bt, Z as gt } from "./index-t74PT2zd.js";
-import { g as vt, m as j } from "./panel-config-BNLlUc_r.js";
+import { b as ft, p as wt, u as ht, a as Ne, A as bt, Z as gt } from "./index-BeYH-tJD.js";
+import { g as vt, m as j } from "./panel-config-7Xg59uKj.js";
 const xt = (e, o) => {
   const t = new Array(e.length + o.length);
   for (let r = 0; r < e.length; r++)

package/dist/index.d.ts

@@ -35,6 +35,20 @@
  */
 import './styles/panel.css';
 import { type PanelConfig } from './config/panel-config';
+/**
+ * Test-only: snapshot of the mounted-shell slot registry (prefix -> ordinal).
+ * A copy, so a test cannot mutate the live registry through it.
+ *
+ * Prefixed `__` to make it clear this is internal/test surface, not a
+ * documented public API.
+ */
+export declare function __mountedSpawnSlotsForTests(): ReadonlyMap<string, number>;
+/**
+ * Test-only: drop every registered slot. Unlike the bindings reset this has
+ * no listeners to drain — the registry holds plain numbers — so clearing the
+ * map is the whole teardown.
+ */
+export declare function __resetSpawnSlotsForTests(): void;
 export { configurePanel, setPanelColorPresets } from './config/panel-config';
 export type { PanelConfig, PanelInstanceHandle, ApplySink } from './config/panel-config';
 /**

package/dist/index.js

@@ -1,37 +1,39 @@
 import "preact/jsx-runtime";
 import "preact";
-import { S as i, c as t, d as n, _ as l, e as d, f as _, g, h as p, i as P, j as m, k as A, l as C, m as u, n as c, o as f, q as K, r as M, s as T, t as v, v as S, w as E, x as h } from "./index-t74PT2zd.js";
-import { Z as D, U as k, v as y, u as F, X as H } from "./tweak-state-Dti6XMoQ.js";
-import { c as b, s as w } from "./panel-config-BNLlUc_r.js";
-import "./autoload-state-CFmRjtD-.js";
+import { S as t, c as i, d as n, _ as l, e as d, f as _, g as p, h as g, i as m, j as P, k as u, l as A, m as C, n as S, o as T, q as c, r as f, s as K, t as M, v, w as E, x as F, y as h, z as w } from "./index-BeYH-tJD.js";
+import { Z as y, U as D, v as k, u as H, X as L } from "./tweak-state-DRKV1uYj.js";
+import { c as O, s as V } from "./panel-config-7Xg59uKj.js";
+import "./autoload-state-CTDDBxI8.js";
 export {
-  i as SCHEMA_V1,
-  t as SCHEMA_V2,
+  t as SCHEMA_V1,
+  i as SCHEMA_V2,
   n as SCHEMA_V3,
-  D as ZDTP_LEGACY_TYPOGRAPHY_RENAME_MAP,
-  l as __panelConfigForTest,
-  d as __reapplyFromStorageForTests,
-  _ as __resetInstanceBindingsForTests,
-  b as configurePanel,
-  g as disableAutoload,
-  k as emptyOverrides,
-  p as enableAutoload,
-  y as getClusterDefaultMode,
-  P as hideDesignTokenPanel,
-  m as isColorKind,
-  A as isContentKind,
-  C as isCursorKind,
-  u as isLengthKind,
+  y as ZDTP_LEGACY_TYPOGRAPHY_RENAME_MAP,
+  l as __mountedSpawnSlotsForTests,
+  d as __panelConfigForTest,
+  _ as __reapplyFromStorageForTests,
+  p as __resetInstanceBindingsForTests,
+  g as __resetSpawnSlotsForTests,
+  O as configurePanel,
+  m as disableAutoload,
+  D as emptyOverrides,
+  P as enableAutoload,
+  k as getClusterDefaultMode,
+  u as hideDesignTokenPanel,
+  A as isColorKind,
+  C as isContentKind,
+  S as isCursorKind,
+  T as isLengthKind,
   c as isMaskImageKind,
   f as isNumberKind,
   K as isSelectKind,
   M as isTextKind,
-  T as reapplyPersistedOverrides,
-  F as resolvePerModeLiteral,
-  H as resolveSemanticPreviewColor,
-  v as setLifecycleAdapter,
-  w as setPanelColorPresets,
-  S as shouldAutoload,
-  E as showDesignTokenPanel,
-  h as toggleDesignPanel
+  v as reapplyPersistedOverrides,
+  H as resolvePerModeLiteral,
+  L as resolveSemanticPreviewColor,
+  E as setLifecycleAdapter,
+  V as setPanelColorPresets,
+  F as shouldAutoload,
+  h as showDesignTokenPanel,
+  w as toggleDesignPanel
 };

package/dist/{panel-config-BNLlUc_r.js → panel-config-7Xg59uKj.js}

@@ -336,10 +336,10 @@ const _ = {
   // No bundled apply endpoint / routing — hosts wire their own.
   applyEndpoint: void 0,
   applyRouting: void 0
-}, R = /* @__PURE__ */ Symbol.for("@takazudo/zdtp:singleton");
+}, O = /* @__PURE__ */ Symbol.for("@takazudo/zdtp:singleton");
 function m() {
   const e = globalThis;
-  let t = e[R];
+  let t = e[O];
   return t || (t = {
     instances: /* @__PURE__ */ new Map(),
     defaultPrefix: null,
@@ -347,7 +347,7 @@ function m() {
     pendingPostConfigureHooks: [],
     lifecycleHooks: {},
     colorSchemeOwners: /* @__PURE__ */ new Set()
-  }, e[R] = t), t;
+  }, e[O] = t), t;
 }
 function F(e) {
   return {
@@ -499,19 +499,19 @@ function Ce(e, t) {
 function Pe(e) {
   return `${e.exportFilenameBase}.json`;
 }
-const O = /* @__PURE__ */ Symbol.for("@takazudo/zdtp:global-alias-marker");
+const R = /* @__PURE__ */ Symbol.for("@takazudo/zdtp:global-alias-marker");
 function Ee(e) {
   if (typeof window > "u") return;
   const t = window, n = t.zdtp;
   if (n !== void 0) {
-    if ((typeof n == "object" || typeof n == "function") && n !== null && n[O] === !0) return;
+    if ((typeof n == "object" || typeof n == "function") && n !== null && n[R] === !0) return;
     console.warn(
       "[design-token-panel] window.zdtp already exists and was not installed by this package. Skipping the zdtp.show() / zdtp.hide() / zdtp.toggle() global alias to avoid clobbering it. Use window[consoleNamespace].* or the configurePanel(cfg) handle instead."
     );
     return;
   }
   const i = { ...e };
-  i[O] = !0, t.zdtp = i;
+  i[R] = !0, t.zdtp = i;
 }
 function ve(e) {
   if (e === null || typeof e != "object" || Array.isArray(e))
@@ -565,6 +565,10 @@ function ve(e) {
         );
     }
   }
+  if (t.autoRememberOnOpen !== void 0 && typeof t.autoRememberOnOpen != "boolean")
+    throw new Error(
+      `[design-token-panel] PanelConfig.autoRememberOnOpen must be a boolean when set (got ${typeof t.autoRememberOnOpen})`
+    );
   if (t.legacyIdRenameMap !== void 0) {
     if (t.legacyIdRenameMap === null || typeof t.legacyIdRenameMap != "object" || Array.isArray(t.legacyIdRenameMap))
       throw new Error("[design-token-panel] PanelConfig.legacyIdRenameMap must be a plain object");
@@ -926,17 +930,17 @@ export {
   be as K,
   oe as _,
   he as a,
-  fe as b,
+  ve as b,
   ee as c,
-  ce as d,
-  ge as e,
-  ve as f,
+  ue as d,
+  pe as e,
+  de as f,
   D as g,
-  ue as h,
+  fe as h,
   Ee as i,
-  pe as j,
-  de as k,
-  we as l,
+  we as j,
+  ge as k,
+  ce as l,
   Ce as m,
   se as n,
   le as o,

package/dist/panel.d.ts

@@ -10,9 +10,16 @@ import { type PanelConfig } from './config/panel-config';
  * distinct sync events, and render distinct manifests, never cross-talking.
  * Omitted (e.g. a direct test render) → the active/default instance, preserving
  * the historical single-panel behaviour.
+ *
+ * `spawnOrdinal` is this shell's slot in the mounted-shell registry (#584),
+ * handed down by the adapter at `render(...)` time. It cascades the FIRST-OPEN
+ * position of concurrently mounted instances apart (#585) so a second panel
+ * stops landing exactly on top of the first; a persisted position ignores it.
+ * Omitted → 0, i.e. no offset.
  */
 interface DesignTokenTweakPanelProps {
     instanceConfig?: PanelConfig;
+    spawnOrdinal?: number;
 }
-export default function DesignTokenTweakPanel({ instanceConfig: instanceConfigProp, }?: DesignTokenTweakPanelProps): import("preact").JSX.Element;
+export default function DesignTokenTweakPanel({ instanceConfig: instanceConfigProp, spawnOrdinal, }?: DesignTokenTweakPanelProps): import("preact").JSX.Element;
 export type { TweakState } from './state/tweak-state';

package/dist/state/autoload-state.d.ts

@@ -3,31 +3,66 @@
  *
  * ## Flag semantics
  *
- * `${storagePrefix}:autoload` (written as `'1'` when armed, `'0'` or absent
- * when not) is the owner-mode flag. It means:
+ * `${storagePrefix}:autoload` is the owner-mode flag. It means:
  *   "This browser visited the site as the site owner — autoload the
  *    design-token panel on every subsequent page visit."
  *
+ * The stored value carries the flag's **provenance** — how the browser came to
+ * be in owner mode:
+ *
+ * - `'1'` — **explicit**: the owner deliberately armed owner mode. Written only
+ *   by `enableAutoload()` (via `setAutoload(cfg, true)`).
+ * - `'auto'` — **auto-remembered**: something merely opened the panel once.
+ *   Written by `rememberAutoload()` from the five auto-remember sites —
+ *   `showInstance` / `toggleInstance` / the header-button + window-event
+ *   handler in `index.tsx`, and `showDesignPanel` / the toggle handler in
+ *   `astro/host-adapter.ts`.
+ * - `'0'`, absent, or any other value — **not in owner mode**. Written by
+ *   `setAutoload(cfg, false)`; `clearAutoload()` removes the key outright.
+ *
+ * The split exists so a **downstream host** can discriminate the two
+ * populations — e.g. keep an `=== '1'` probe and stop eagerly fetching the
+ * panel bundle for a visitor who clicked a panel button once months ago.
+ *
+ * **zdtp's own gates honour BOTH values.** `shouldAutoload()` is `true` for
+ * `'1'` and `'auto'` alike, so an owner who reached owner mode by opening the
+ * panel still gets the auto-reload this module documents. Making zdtp's own
+ * gate ignore `'auto'` would be a silent behaviour regression for every
+ * existing user — the discrimination lives in the *stored value*, not in
+ * zdtp's behaviour.
+ *
+ * Auto-remember never **downgrades** an existing `'1'`: an owner who armed
+ * explicitly and then opens the panel keeps the explicit provenance.
+ *
+ * ### Legacy values are forward-looking only
+ *
+ * Browsers that auto-remembered BEFORE the provenance value existed already
+ * hold `'1'`, and no migration can recover a provenance that was never stored.
+ * They therefore read as explicit owners forever. A downstream host must not
+ * expect an `=== '1'` probe to immediately shed its whole legacy population —
+ * the discrimination only applies to writes made from this version onward.
+ *
  * ## General-visitor vs owner behavior
  *
- * - **General visitor** (flag absent or `!== '1'`): the panel bundle is NOT
- *   eagerly fetched. Gate #1 (`shouldAutoload`) returns false, so no bundle
- *   request fires on page load. The panel remains entirely invisible.
- * - **Owner** (flag === `'1'`): Gate #1 fires, the host-adapter fetches the
- *   bundle eagerly, and Gate #2 (`reapplyFromStorage` in `index.tsx`) mounts
- *   the Preact shell CLOSED so the element-path inspector is available even
- *   while the panel UI is hidden.
+ * - **General visitor** (flag absent, `'0'`, or any unrecognised value): the
+ *   panel bundle is NOT eagerly fetched. Gate #1 (`shouldAutoload`) returns
+ *   false, so no bundle request fires on page load. The panel remains entirely
+ *   invisible.
+ * - **Owner** (flag `'1'` or `'auto'`): Gate #1 fires, the host-adapter fetches
+ *   the bundle eagerly, and Gate #2 (`reapplyFromStorage` in `index.tsx`)
+ *   mounts the Preact shell CLOSED so the element-path inspector is available
+ *   even while the panel UI is hidden.
  *
  * ## enableAutoload() / disableAutoload() contract (implemented by S2 #419)
  *
  * `enableAutoload()` (console API, wired by S2):
- *   1. Sets `:autoload = '1'`.
+ *   1. Sets `:autoload = '1'` (explicit provenance).
  *   2. Sets `-elpath-enabled = '1'` once (arms the alt+click inspector).
  *   3. Loads the panel bundle (if not already loaded).
  *   4. Mounts the Preact shell CLOSED via `hideInstance`.
  *
  * `disableAutoload()` (console API, wired by S2):
- *   1. Clears `:autoload`.
+ *   1. Clears `:autoload` (removes the key, whichever value it held).
  *   2. Clears `:visible`.
  *   3. Clears `-elpath-enabled`.
  *   4. Clears the open-state key (`getOpenKey(cfg)` from `state/tweak-state`).
@@ -36,9 +71,17 @@
  * ## Auto-remember
  *
  * Any action that shows the panel (console `showDesignPanel()`, the header-
- * button open event, or the `showInstance` path in `index.tsx`) MUST also
- * write `:autoload = '1'`. Once an owner opens the panel the flag is set so
- * subsequent page loads reload it automatically. (Wired by S2 / S3.)
+ * button open event, or the `showInstance` path in `index.tsx`) MUST also call
+ * `rememberAutoload(cfg)`, which writes `:autoload = 'auto'`. Once the panel
+ * has been opened the flag is set so subsequent page loads reload it
+ * automatically. (Wired by S2 / S3.)
+ *
+ * A host can opt out of this entirely by setting `PanelConfig.autoRememberOnOpen
+ * = false` — `rememberAutoload` then becomes a no-op, so opening the panel
+ * never persists owner-mode. This exists for a public docs site that wants a
+ * visible panel button for every visitor without arming owner-mode for
+ * whoever clicks it. `enableAutoload()` (which writes `'1'` via `setAutoload`,
+ * not this function) is unaffected either way.
  *
  * ## Element-path coupling
  *
@@ -64,26 +107,53 @@
  * are persisted yet.
  */
 import type { PanelConfig } from '../config/panel-config';
+/** Stored `:autoload` value meaning "the owner armed owner mode deliberately". */
+export declare const AUTOLOAD_EXPLICIT = "1";
+/** Stored `:autoload` value meaning "owner mode was inferred from a panel open". */
+export declare const AUTOLOAD_AUTO_REMEMBERED = "auto";
 /**
- * Return `true` iff this browser has the owner-autoload flag set.
+ * Return `true` iff this browser has the owner-autoload flag set, regardless of
+ * how it got there.
  *
  * SSR-safe (returns `false` when `window` is not available) and quota-
  * tolerant (returns `false` on any storage error). Reads exactly
- * `${cfg.storagePrefix}:autoload` and matches against the literal string
- * `'1'`; any other stored value (including `'0'` or an absent key) is `false`.
+ * `${cfg.storagePrefix}:autoload` and matches `'1'` (explicit) or `'auto'`
+ * (auto-remembered); any other stored value — including `'0'` and an absent
+ * key — is `false`.
  */
 export declare function shouldAutoload(cfg: PanelConfig): boolean;
 /**
- * Write the owner-autoload flag. Pass `true` to arm autoload (`'1'`), `false`
- * to disarm (`'0'`). SSR-safe and quota-tolerant — errors are swallowed
- * silently so this never throws in restricted storage contexts.
+ * Write the owner-autoload flag with EXPLICIT provenance. Pass `true` to arm
+ * autoload (`'1'`), `false` to disarm (`'0'`). SSR-safe and quota-tolerant —
+ * errors are swallowed silently so this never throws in restricted storage
+ * contexts.
+ *
+ * Reserved for the deliberate `enableAutoload()` path; auto-remember call sites
+ * use `rememberAutoload` so the two populations stay distinguishable in storage.
  *
  * Prefer `clearAutoload` when you want to fully remove the key (e.g. on
  * `disableAutoload`) rather than leave a `'0'` sentinel.
  */
 export declare function setAutoload(cfg: PanelConfig, on: boolean): void;
 /**
- * Remove the owner-autoload flag from storage entirely.
+ * Arm the owner-autoload flag with AUTO-REMEMBERED provenance (`'auto'`).
+ *
+ * Called from every auto-remember site — any action that merely opens the panel.
+ * An existing explicit `'1'` is left untouched: an owner who armed owner mode
+ * deliberately must not demote themselves by opening the panel.
+ *
+ * No-op when `cfg.autoRememberOnOpen === false` — see that field's doc for the
+ * public-site use case. The gate lives HERE (not at each call site) so a
+ * future auto-remember site inherits it automatically instead of needing its
+ * own opt-out check. `enableAutoload()` calls `setAutoload`, not this
+ * function, so it is never subject to this gate.
+ *
+ * SSR-safe and quota-tolerant.
+ */
+export declare function rememberAutoload(cfg: PanelConfig): void;
+/**
+ * Remove the owner-autoload flag from storage entirely, whichever provenance
+ * value it held.
  *
  * Called by `disableAutoload()` (S2) as part of the full owner-mode teardown.
  * SSR-safe and quota-tolerant.

package/dist/state/tweak-state.d.ts

@@ -104,16 +104,36 @@ export declare const DEFAULT_POSITION: PanelPosition;
 /**
  * Compute a viewport-centered default panel position for first-open behaviour.
  *
- * The panel CSS-sizes itself up to 1200×800 but caps at 80% of the viewport,
- * so we mirror the same min/0.8x rule here. The resulting `top` / `left`
- * place the panel at the geometric center of the viewport.
+ * Delegates to `defaultGeometry()` so the position is centered against the
+ * panel's *actual* clamped default size rather than an independently derived
+ * one — see that function for why the two must not be computed separately.
+ *
+ * `spawnOrdinal` cascades concurrently-mounted instances apart; ordinal 0 (the
+ * default, and the only ordinal a single-panel host ever sees) is exactly the
+ * centered position. `size`, when given, is the rectangle to center — pass the
+ * size the panel will actually render at rather than letting the default size
+ * be assumed.
  *
  * Falls back to the static `DEFAULT_POSITION` when `window` is undefined
  * (e.g. SSR / node test setup without jsdom). Real browsers + jsdom-backed
  * tests get the centered position.
  */
-export declare function defaultPosition(): PanelPosition;
-export declare function loadPosition(cfg?: PanelConfig): PanelPosition;
+export declare function defaultPosition(spawnOrdinal?: number, size?: PanelSize): PanelPosition;
+/**
+ * Read this instance's persisted position, falling back to the cascaded
+ * first-open default.
+ *
+ * `spawnOrdinal` is applied ONLY to the fallback. A stored position is an
+ * explicit user preference — a panel the user dragged somewhere reopens
+ * exactly there, never nudged by however many siblings happen to be mounted.
+ *
+ * `size` is the size the caller will actually render at (i.e. `loadSize()`'s
+ * result). Pass it so the fallback is centered and contained against THAT
+ * rectangle: an instance with a persisted size but no persisted position
+ * would otherwise be centered as if it were the default width and spawn
+ * partly off-screen.
+ */
+export declare function loadPosition(cfg?: PanelConfig, spawnOrdinal?: number, size?: PanelSize): PanelPosition;
 export declare function savePosition(pos: PanelPosition, cfg?: PanelConfig): void;
 /** Keep at least VISIBLE_MIN px of the panel on-screen so the user can grab it back. */
 export declare const VISIBLE_MIN = 60;
@@ -141,6 +161,8 @@ export declare const DEFAULT_SIZE: PanelSize;
  * result respects the MIN_PANEL_* floor and the viewport cap. The floor only
  * bites on phone-width viewports (e.g. 375px → 0.8*375 = 300, raised to the
  * 320 min); on normal viewports the clamp is a no-op.
+ *
+ * Delegates to `defaultGeometry()` — the single place the rule lives.
  */
 export declare function defaultSize(): PanelSize;
 /**
@@ -149,6 +171,52 @@ export declare function defaultSize(): PanelSize;
  * from rendering off-screen when reopened on a 1080p laptop.
  */
 export declare function clampSize(width: number, height: number): PanelSize;
+/** Per-ordinal cascade step, in px, applied to both axes on a fresh spawn. */
+export declare const SPAWN_CASCADE_STEP = 24;
+/** Position + size of a panel, as one coherent rectangle. */
+export interface PanelGeometry extends PanelPosition, PanelSize {
+}
+/**
+ * Compute the coherent first-open geometry: the clamped default size, plus a
+ * position that centers *that* rectangle in the viewport.
+ *
+ * Position and size used to be derived independently — `defaultPosition()`
+ * centered a phantom `min(1200, 0.8 * vw)` panel while `defaultSize()` raised
+ * that same value to the `MIN_PANEL_WIDTH` floor. On a 320px viewport the two
+ * disagreed by 32px (left 32 + width 320 = 352) and the panel spawned partly
+ * off-screen; `clampPosition()` did not catch it because it is a permissive
+ * drag-recovery clamp that only guarantees `VISIBLE_MIN` px stays grabbable.
+ * Computing the size first and centering against it keeps them in lockstep,
+ * and is the reason `defaultPosition()` / `defaultSize()` are thin wrappers
+ * rather than independent implementations.
+ *
+ * `spawnOrdinal` (from the mount layer's slot registry) cascades a second and
+ * third concurrently-mounted instance away from the first — see
+ * `SPAWN_CASCADE_STEP` and `clampSpawnPosition`. Ordinal 0 takes no offset, so
+ * a single-panel host is byte-identical to the pre-cascade behaviour.
+ *
+ * The ordinal travels mount layer -> geometry, never the reverse: this module
+ * must not import `index.tsx` (epic #582, decision 4).
+ *
+ * Falls back to the static SSR constants when `window` is undefined.
+ */
+export declare function defaultGeometry(spawnOrdinal?: number, sizeOverride?: PanelSize): PanelGeometry;
+/**
+ * Clamp a FRESH-SPAWN position so the whole panel sits inside the viewport:
+ * `left ∈ [0, max(0, innerWidth - panelWidth)]`, `top` likewise.
+ *
+ * Deliberately NOT `clampPosition()`. That one is the drag-recovery clamp and
+ * is permissive on purpose — it lets a panel the user dragged hang off the
+ * edge so long as `VISIBLE_MIN` px stay grabbable. Spawn containment is a
+ * stricter, separate rule (epic #582, decision 2), so it gets its own clamp
+ * rather than tightening a clamp other behaviour depends on.
+ *
+ * Containment beats distinctness: on a viewport with no spare room the upper
+ * bound collapses to 0 and the cascade degrades — reduced first, dropped
+ * entirely when there is nothing left. Two instances may then coincide. That
+ * is the documented trade-off; a panel spawned off-screen is worse.
+ */
+export declare function clampSpawnPosition(top: number, left: number, panelWidth: number, panelHeight: number): PanelPosition;
 export declare function loadSize(cfg?: PanelConfig): PanelSize;
 export declare function saveSize(size: PanelSize, cfg?: PanelConfig): void;
 /**

package/dist/testing.js

@@ -1,8 +1,8 @@
-import { _ as r, c as _, h as i, j as n, k as g, b as R, a as p } from "./panel-config-BNLlUc_r.js";
-import { a as y, b as O, l as P } from "./tweak-state-Dti6XMoQ.js";
+import { _ as r, c as _, d as i, e as n, f as g, h as R, a as p } from "./panel-config-7Xg59uKj.js";
+import { a as l, b as y, l as O } from "./tweak-state-DRKV1uYj.js";
 import { F as K, G as E, a as S, S as u } from "./manifest-DCReQE0k.js";
-async function s(a, e) {
-  await a.fill(e), await a.dispatchEvent("input");
+async function s(e, a) {
+  await e.fill(a), await e.dispatchEvent("input");
 }
 export {
   K as FONT_GROUP_ORDER,
@@ -11,9 +11,9 @@ export {
   u as SIZE_GROUP_ORDER,
   r as __resetPanelConfigForTests,
   _ as configurePanel,
-  y as getStorageKeyV1,
-  O as getStorageKeyV2,
-  P as loadPersistedState,
+  l as getStorageKeyV1,
+  y as getStorageKeyV2,
+  O as loadPersistedState,
   s as setPanelInputValue,
   i as storageKey_open,
   n as storageKey_position,