@m4l/testing 0.0.23 → 1.0.1

package/playwright/index.js

@@ -0,0 +1,2041 @@
+import { expect as T } from "@playwright/test";
+const ie = {
+  id: "area_testing_1",
+  name: "Workspace 1"
+};
+function K(e = {}) {
+  return {
+    ...ie,
+    ...e
+  };
+}
+function re(e) {
+  const { data: t, pagerPage: o = 0, total: a = t.length } = e;
+  return {
+    data: t,
+    pager: { page: o, total: a }
+  };
+}
+const U = {
+  data: {
+    module_name: "Shared Host Module",
+    module_description: "Deterministic host-shell test dictionary"
+  }
+};
+function C(e = {}) {
+  const { data: t = {}, sections: o = {} } = e;
+  return {
+    ...U,
+    ...o,
+    data: {
+      ...U.data,
+      ...t
+    }
+  };
+}
+const se = "Deterministic authenticated host-preview module dictionary.";
+function ne(e) {
+  const {
+    moduleName: t,
+    moduleDescription: o = se,
+    data: a = {},
+    sections: i = {}
+  } = e;
+  return C({
+    data: {
+      module_name: t,
+      module_description: o,
+      ...a
+    },
+    sections: i
+  });
+}
+const ce = "Operations";
+function le(e) {
+  const {
+    moduleId: t,
+    title: o,
+    debugPort: a,
+    iconUrl: i,
+    dynamicParams: r,
+    sectionTitle: s = ce
+  } = e;
+  return [
+    {
+      title: s,
+      children: [
+        {
+          title: o,
+          moduleId: t,
+          debugPort: a,
+          ...i ? { iconUrl: i } : {},
+          ...r ? { dynamicParams: r } : {}
+        }
+      ]
+    }
+  ];
+}
+const x = {
+  user: {
+    email: "taylor.system@example.test",
+    id: 42,
+    firstName: "Taylor",
+    lastName: "System",
+    accountId: 7,
+    domainCountry: {
+      currency: "USD",
+      currencyDecimalDigits: 2,
+      decimalSymbol: ".",
+      thousandsSymbol: ","
+    },
+    avatarUrl: "https://example.test/testing/assets/avatar.png",
+    sessionId: "session-testing-1",
+    dbType: "dt_operative"
+  }
+};
+function de(e = {}) {
+  return {
+    user: {
+      ...x.user,
+      ...e,
+      domainCountry: {
+        ...x.user.domainCountry,
+        ...e.domainCountry
+      }
+    }
+  };
+}
+const ue = {
+  id: "admin",
+  container_id: "areas",
+  value: JSON.stringify({ selectedAreaId: K().id })
+};
+function pe(e = {}) {
+  return {
+    ...ue,
+    ...e
+  };
+}
+const N = {
+  error: {
+    code: 401,
+    message: "Unauthorized"
+  }
+};
+function me(e = {}) {
+  return {
+    ...N,
+    ...e,
+    error: {
+      ...N.error,
+      ...e.error
+    }
+  };
+}
+const ge = {
+  lang: "en",
+  region: "US",
+  urlIcon: "frontend/commons/assets/icons/langs/lang_en.svg",
+  name: "English US"
+};
+function ye(e = {}) {
+  return {
+    ...ge,
+    ...e
+  };
+}
+function Ut(e = {}) {
+  const {
+    disableSelectionAutofocus: t,
+    dummyPresetId: o,
+    testCondition: a,
+    ...i
+  } = e;
+  return {
+    ...i,
+    ...t !== void 0 ? { disableSelectionAutofocus: t } : {},
+    ...o ? { dummyPresetId: o } : {},
+    ...a ? { testCondition: a } : {}
+  };
+}
+const fe = {
+  privacyPolicyLink: "https://example.test/privacy-policy",
+  useTerms: "https://example.test/terms-of-service",
+  assetLogoUrl: "testing/assets/company-logo.svg",
+  assetUserInterfaceLogoUrl: "testing/assets/platform-logo.svg",
+  assetDocumentsLogoUrl: "testing/assets/documents-logo.svg",
+  assetNotificationsLogoUrl: "testing/assets/notifications-logo.svg",
+  assetLoginBackgroundUrl: "testing/assets/login-background.jpg",
+  assetFaviconUrl: "testing/assets/favicon.svg",
+  assetLogoMobileUrl: "testing/assets/company-logo-mobile.svg",
+  browserName: "GClick Test Host",
+  bottomTitle: "GClick Platform",
+  dbType: "dt_operative"
+};
+function W(e = {}) {
+  return {
+    ...fe,
+    ...e
+  };
+}
+const h = {
+  locale: {
+    id: "en-US",
+    name: "English (United States)"
+  },
+  time_zone: {
+    id: 1,
+    name: "America/Bogota",
+    title: "America/Bogota",
+    base_offset: -5,
+    dst_offset: 0,
+    country_code: "CO"
+  },
+  date_format: {
+    id: 1,
+    name: "date",
+    description: "date",
+    format: "yyyy-MM-dd"
+  },
+  time_format: {
+    id: 1,
+    name: "time",
+    description: "time",
+    format: "HH:mm:ss"
+  },
+  decimal_symbol: ".",
+  thousands_symbol: ",",
+  currency: "USD",
+  currency_decimal_digits: 2
+};
+function be(e = {}) {
+  const t = e.locale ? { ...h.locale, ...e.locale } : h.locale, o = e.time_zone ? { ...h.time_zone, ...e.time_zone } : h.time_zone, a = e.date_format ? { ...h.date_format, ...e.date_format } : h.date_format, i = e.time_format ? { ...h.time_format, ...e.time_format } : h.time_format;
+  return {
+    ...h,
+    ...e,
+    locale: t,
+    time_zone: o,
+    date_format: a,
+    time_format: i
+  };
+}
+async function xt(e, t, o) {
+  await e.attach(t, {
+    body: JSON.stringify(o, null, 2),
+    contentType: "application/json"
+  });
+}
+function we(e) {
+  return e.getByRole("region", { name: "formContainer" });
+}
+function z(e, t) {
+  return we(e).locator(`[name="${t}"]`);
+}
+function he(e) {
+  return e.getByRole("group", { name: "actionsContainer" });
+}
+function Nt(e, t) {
+  return e.getByRole("alert").filter({ hasText: t });
+}
+function Gt(e) {
+  return e.getByRole("dialog");
+}
+function jt(e, t) {
+  return he(e).getByRole("button", { name: t });
+}
+async function $t(e) {
+  const { page: t, name: o, endpointPattern: a, search: i } = e, r = z(t, o), s = t.waitForRequest(
+    (n) => n.method() === "GET" && a.test(n.url())
+  );
+  return await r.click(), i && await r.fill(i), s;
+}
+function Vt(e) {
+  return e.getByRole("listbox").getByRole("option");
+}
+async function qt(e) {
+  const { page: t, name: o, optionLabel: a, search: i } = e, r = z(t, o);
+  await r.click(), i && await r.fill(i);
+  const s = t.getByRole("listbox"), n = a ? s.getByRole("option", { name: a }).first() : s.getByRole("option").first();
+  await n.waitFor({ state: "visible" }), await n.click();
+}
+function Yt(e) {
+  return e.length === 0 ? "All checks passed." : e.map((t) => {
+    const o = t.actual === null ? "null" : String(t.actual);
+    return `${t.key}: expected ${String(t.threshold)}, received ${o}`;
+  }).join(`
+`);
+}
+function k(e) {
+  return e.getByRole("grid");
+}
+function J(e) {
+  return k(e).locator(
+    '[role="row"]:has([role="gridcell"])'
+  );
+}
+function Kt(e, t) {
+  return k(e).getByRole("gridcell", {
+    name: t,
+    exact: !0
+  });
+}
+function I(e, t = 0) {
+  return J(e).nth(t);
+}
+async function Wt(e, t = 0) {
+  await I(e, t).getByRole("button", { name: "menu-actions" }).click();
+}
+async function zt(e, t = 0) {
+  await I(e, t).getByRole("gridcell").nth(1).dblclick();
+}
+async function Jt(e, t = 0) {
+  await I(e, t).getByRole("gridcell").nth(1).click();
+}
+async function Xt(e) {
+  const t = k(e).locator(
+    '[role="gridcell"][aria-selected="true"]'
+  );
+  return await t.waitFor({ state: "visible" }), t.evaluate((o) => ({
+    rowIndex: Number(
+      o.closest('[role="row"]')?.getAttribute("aria-rowindex") ?? Number.NaN
+    ),
+    columnIndex: Number(o.getAttribute("aria-colindex") ?? Number.NaN)
+  }));
+}
+function X(e) {
+  return k(e).getByRole("button", {
+    name: /^header-column-button-/
+  });
+}
+const Qt = [
+  "toggle-freeze",
+  "hide-column"
+];
+function M(e) {
+  return ("mouse" in e ? e : e.page()).locator('[data-testid="PopoverRoot"]');
+}
+async function Zt(e, t) {
+  await k(e).getByRole("button", {
+    name: `header-column-button-${t}`,
+    exact: !0
+  }).click(), await M(e).waitFor({ state: "visible" });
+}
+async function eo(e) {
+  const t = M(e).getByRole("menuitem");
+  return await t.first().waitFor({ state: "visible" }), t.evaluateAll(
+    (o) => o.map((a) => ({
+      action: a.getAttribute("aria-label") ?? "",
+      disabled: a.getAttribute("aria-disabled") === "true"
+    }))
+  );
+}
+async function to(e, t) {
+  await M(e).getByRole("menuitem", { name: t, exact: !0 }).click();
+}
+async function oo(e) {
+  await M(e).locator(".MuiBackdrop-root").click({ force: !0, position: { x: 5, y: 5 } }), await M(e).waitFor({ state: "detached" });
+}
+function Q(e, t) {
+  return k(e).locator(
+    `[role="columnheader"]:has([aria-label="header-column-button-${t}"])`
+  );
+}
+async function ve(e, t) {
+  const o = Q(e, t);
+  await o.waitFor({ state: "visible" });
+  const a = await o.boundingBox();
+  if (!a)
+    throw new Error(`Column "${t}" has no rendered box to measure.`);
+  return Math.round(a.width);
+}
+async function ao(e, t, o) {
+  const a = "mouse" in e ? e : e.page(), i = Q(e, t);
+  await i.waitFor({ state: "visible" });
+  const r = await i.boundingBox();
+  if (!r)
+    throw new Error(`Column "${t}" has no rendered box to resize.`);
+  const s = r.x + r.width - 3, n = r.y + r.height / 2;
+  return await a.mouse.move(s, n), await a.mouse.down(), await a.mouse.move(s + o, n, { steps: 12 }), await a.mouse.up(), ve(e, t);
+}
+async function _e(e) {
+  const t = X(e);
+  return await t.first().waitFor({ state: "visible" }), (await t.evaluateAll(
+    (a) => a.map((i) => i.getAttribute("aria-label") ?? "")
+  )).map((a) => a.replace("header-column-button-", ""));
+}
+async function io(e) {
+  const t = k(e);
+  await t.waitFor({ state: "visible" });
+  const o = X(e);
+  await o.first().waitFor({ state: "visible" }), await t.evaluate(async (i) => {
+    i.scrollTo({ left: 0, behavior: "instant" }), await new Promise((r) => {
+      requestAnimationFrame(() => r(null));
+    });
+  });
+  const a = {};
+  for (; ; ) {
+    const i = await o.evaluateAll(
+      (s) => s.map((n) => ({
+        key: (n.getAttribute("aria-label") ?? "").replace(
+          "header-column-button-",
+          ""
+        ),
+        align: /rdg-cell-align-(left|center|right)/.exec(
+          n.closest('[role="columnheader"]')?.className ?? ""
+        )?.[1] ?? ""
+      }))
+    );
+    for (const { key: s, align: n } of i)
+      s && !(s in a) && (a[s] = n);
+    if (await t.evaluate(async (s) => {
+      const n = s.scrollLeft, l = n + Math.max(s.clientWidth - 120, 120);
+      return s.scrollTo({ left: l, behavior: "instant" }), await new Promise((p) => {
+        requestAnimationFrame(() => p(null));
+      }), s.scrollLeft === n;
+    }))
+      break;
+  }
+  return await t.evaluate((i) => {
+    i.scrollTo({ left: 0, behavior: "instant" });
+  }), a;
+}
+async function ro(e) {
+  const t = k(e);
+  await t.waitFor({ state: "visible" });
+  const o = [];
+  for (; ; ) {
+    for (const i of await _e(e))
+      o.includes(i) || o.push(i);
+    if (await t.evaluate(async (i) => {
+      const r = i.scrollLeft, s = r + Math.max(i.clientWidth - 120, 120);
+      return i.scrollTo({ left: s, behavior: "instant" }), await new Promise((n) => {
+        requestAnimationFrame(() => n(null));
+      }), i.scrollLeft === r;
+    }))
+      break;
+  }
+  return await t.evaluate((a) => {
+    a.scrollTo({ left: 0, behavior: "instant" });
+  }), o;
+}
+async function so(e, t = 0) {
+  const o = e.locator('[data-testid="data-grid-card"], [data-testid="list-row"]').nth(t);
+  return await o.waitFor({ state: "attached" }), (await o.locator('[data-testid^="datagrid-field-"]').evaluateAll(
+    (r) => r.map((s) => s.getAttribute("data-testid") ?? "")
+  )).map((r) => r.replace("datagrid-field-", ""));
+}
+function no(e) {
+  return e.getByRole("alert", { name: "NoItemSelected" });
+}
+function co(e, t) {
+  return e.getByRole("listitem").filter({ hasText: t }).last();
+}
+function ke(e, t) {
+  return e.getByRole("heading", { name: t });
+}
+async function lo(e, t) {
+  await ke(e, t).click();
+}
+function Re(e) {
+  return e.getByRole("region");
+}
+async function uo(e) {
+  const t = Re(e);
+  await t.first().waitFor({ state: "visible" });
+  const o = t.getByRole("listitem");
+  return await o.first().waitFor({ state: "visible" }), (await o.allInnerTexts()).map((a) => a.split(`
+`)[0].trim());
+}
+async function po(e) {
+  const { page: t, logsTabName: o, logsEndpointPattern: a } = e;
+  await t.getByRole("tab", { name: o }).click();
+  const i = t.waitForRequest(
+    (r) => a.test(r.url())
+  );
+  return await t.getByRole("button", { name: "refresh", exact: !0 }).last().click(), i;
+}
+async function G(e, t = 1) {
+  await e.click();
+  for (let o = 0; o < t; o += 1)
+    await e.press("ArrowDown");
+  await e.press("Enter");
+}
+async function Ee(e, t) {
+  switch (t.type) {
+    case "string":
+    case "number": {
+      const o = e.getByRole("textbox", { name: "M4LLabel" }).last();
+      await o.fill(t.value ?? ""), await o.press("Enter");
+      return;
+    }
+    case "datetime": {
+      const o = e.locator('input[placeholder="YYYY-MM-DD hh:mm:ss"]');
+      await o.first().waitFor({ state: "visible" }), await o.nth(0).fill(t.value ?? ""), await o.nth(1).fill(t.valueTo ?? t.value ?? ""), await e.getByRole("button", { name: "applyFilter" }).click();
+      return;
+    }
+    case "boolean": {
+      await G(
+        e.locator('input[role="combobox"]').last(),
+        t.value === "false" ? 2 : 1
+      );
+      return;
+    }
+    case "selectAsync": {
+      const o = e.locator('input[role="combobox"]').last();
+      await o.fill(t.value ?? ""), await o.press("ArrowDown"), await o.press("Enter");
+      return;
+    }
+    case "select": {
+      await G(
+        e.locator('input[role="combobox"]').last()
+      );
+      return;
+    }
+  }
+}
+async function Se(e) {
+  const { page: t, scenario: o, endpointPattern: a } = e;
+  await t.getByRole("button", { name: "searchbox" }).first().click(), await t.getByRole("menuitem", { name: o.fieldLabel, exact: !0 }).click(), await Ee(t, o);
+  const i = t.waitForRequest(
+    (r) => a.test(r.url()) && /f\[\d+\]\[n\]=/.test(decodeURIComponent(r.url()))
+  );
+  return await t.getByRole("button", { name: "refresh", exact: !0 }).click(), i;
+}
+async function mo(e) {
+  const { page: t, scenarios: o, endpointPattern: a } = e;
+  let i;
+  for (const r of o)
+    i = await Se({
+      page: t,
+      scenario: r,
+      endpointPattern: a
+    });
+  if (!i)
+    throw new Error(
+      "applyListFiltersAndCaptureRequest requires at least one scenario"
+    );
+  return i;
+}
+function go(e) {
+  return [...decodeURIComponent(e.url()).matchAll(/f\[\d+\]\[n\]=([^&]+)/g)].map((o) => o[1]);
+}
+const yo = "master_applied_filters", fo = "master_applied_sorts";
+function bo(e, t) {
+  return e.waitForRequest(
+    (o) => o.method() === "PUT" && new RegExp(`/cookies/.*${t}`).test(o.url())
+  );
+}
+async function wo(e) {
+  const { page: t, scenario: o, endpointPattern: a } = e;
+  await t.getByRole("button", { name: `header-column-button-${o.columnKey}` }).click();
+  const i = t.waitForRequest(
+    (r) => a.test(r.url()) && /s\[\d+\]\[n\]=/.test(decodeURIComponent(r.url()))
+  );
+  return await t.getByRole("menuitem", { name: "sort-descending" }).click(), i;
+}
+function ho(e) {
+  return [...decodeURIComponent(e.url()).matchAll(/s\[\d+\]\[n\]=([^&]+)/g)].map((o) => o[1]);
+}
+const j = "datagrid-view-";
+async function Te(e) {
+  const t = e.locator(`[aria-label^="${j}"]`);
+  await t.first().waitFor({ state: "attached" });
+  const o = await t.first().getAttribute("aria-label"), a = o?.slice(j.length);
+  if (a !== "table" && a !== "cards" && a !== "list")
+    throw new Error(
+      `Unrecognized datagrid view mode from aria-label "${o}". Expected one of datagrid-view-table | datagrid-view-cards | datagrid-view-list.`
+    );
+  return a;
+}
+async function Ae(e, t) {
+  T(await Te(e)).toBe(t);
+}
+async function Z(e) {
+  await e.getByRole("button", { name: "view-mode" }).click();
+}
+async function vo(e) {
+  await Z(e);
+  const t = "keyboard" in e ? e : e.page(), o = [];
+  for (const a of ["table", "cards", "list"])
+    await t.locator(`[data-testid="toggle-button-${a}"]`).isVisible() && o.push(a);
+  return await Pe(e), o;
+}
+async function Pe(e) {
+  const t = "keyboard" in e ? e : e.page();
+  await t.keyboard.press("Escape"), await T(
+    t.locator('[data-testid="toggle-button-table"]')
+  ).toBeHidden();
+}
+async function _o(e, t) {
+  await Z(e), await ("keyboard" in e ? e : e.page()).locator(`[data-testid="toggle-button-${t}"]`).click(), await Ae(e, t);
+}
+async function Me(e) {
+  const t = "keyboard" in e ? e : e.page();
+  await e.locator('[data-testid="settings-button"]').click(), await T(
+    t.locator('[data-testid="data-grid-settings-intro"]')
+  ).toBeVisible();
+}
+async function ko(e) {
+  const t = "keyboard" in e ? e : e.page();
+  await Me(e), await t.getByRole("button", { name: "un check all" }).click(), await t.locator('[data-testid="data-grid-settings-intro"]').click(), await T(
+    t.locator('[data-testid="data-grid-settings-intro"]')
+  ).toBeHidden();
+}
+function Ro(e, t) {
+  return t === "table" ? J(e) : e.locator(
+    t === "cards" ? '[data-testid="data-grid-card"]' : '[data-testid="list-row"]'
+  );
+}
+const De = "User avatar";
+async function Eo(e) {
+  const {
+    page: t,
+    moduleTitle: o,
+    accountButtonName: a = De
+  } = e;
+  await t.getByRole("button", { name: a }).click();
+  const i = t.getByRole("menuitem", { name: o, exact: !0 });
+  await T(i).toBeVisible(), await i.click();
+}
+const Le = "N_D:[appbar.tooltip_toogle_menu]";
+async function So(e, t) {
+  await e.getByRole("button", { name: Le }).click(), await e.getByRole("menuitem", { name: t, exact: !0 }).click();
+}
+const Oe = '[role="anchored-button"]', Ce = 100, $ = 15e3;
+function Ie(e, t, o) {
+  const a = e.getByRole("menuitem", { name: t, exact: o }).first(), i = o ? e.getByRole("menuitem", { name: t }).first() : a, r = e.getByText(t, { exact: o }).first();
+  return o ? [a, i, r] : [a, r];
+}
+async function V(e, t, o, a) {
+  const i = Date.now(), r = Ie(e, t, o);
+  for (; Date.now() - i < a; ) {
+    for (const s of r)
+      try {
+        if (await s.isVisible())
+          return s;
+      } catch {
+      }
+    await e.waitForTimeout(Ce);
+  }
+  return null;
+}
+async function Fe(e, t, o, a) {
+  const i = await V(
+    e,
+    t,
+    o,
+    $
+  );
+  if (i)
+    return {
+      moduleMenuItem: i,
+      toggleUsed: !1
+    };
+  const r = e.locator(a), s = await r.count();
+  s > 0 && (await T(r).toBeVisible(), await r.click());
+  const n = await V(
+    e,
+    t,
+    o,
+    $
+  );
+  if (!n)
+    throw new Error(`Expected the host sidebar module "${t}" to become visible.`);
+  return {
+    moduleMenuItem: n,
+    toggleUsed: s > 0
+  };
+}
+async function He(e) {
+  const {
+    page: t,
+    moduleTitle: o,
+    exact: a = !0,
+    toggleSelector: i = Oe,
+    waitForModuleOpen: r,
+    maxClickAttempts: s = r ? 2 : 1
+  } = e, n = performance.now(), l = performance.now(), { moduleMenuItem: p, toggleUsed: y } = await Fe(
+    t,
+    o,
+    a,
+    i
+  );
+  let f = 0, m = null;
+  for (let d = 1; d <= s; d += 1) {
+    if (await T(p).toBeVisible(), await p.click({
+      force: y || d > 1,
+      timeout: 1e3
+    }), d === 1 && (f = performance.now() - l), !r)
+      return {
+        clickAttempts: d,
+        directClickMs: f,
+        toggleUsed: y,
+        totalMs: performance.now() - n
+      };
+    try {
+      return await r(t, d), {
+        clickAttempts: d,
+        directClickMs: f,
+        toggleUsed: y,
+        totalMs: performance.now() - n
+      };
+    } catch (u) {
+      m = u;
+    }
+  }
+  throw m instanceof Error ? m : new Error(`Expected the host sidebar module "${o}" to open after ${s} click attempt(s).`);
+}
+async function Be(e) {
+  return He(e);
+}
+async function Ue(e) {
+  const { page: t, count: o = 0 } = e;
+  await t.route("**/alarms/count**", async (a) => {
+    if (a.request().method() !== "GET") {
+      await a.fallback();
+      return;
+    }
+    await a.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        data: {
+          count: o
+        }
+      })
+    });
+  });
+}
+async function xe(e) {
+  const { page: t, areas: o = [K()] } = e;
+  await t.route("**/api/v1/**/areas", async (a) => {
+    if (a.request().method() !== "GET") {
+      await a.fallback();
+      return;
+    }
+    await a.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ data: o })
+    });
+  });
+}
+async function Ne(e) {
+  const { page: t, session: o, status: a = 200, delayMs: i = 0 } = e, r = de(o);
+  await t.route("**/api/v1/**/auth/login**", async (s) => {
+    if (s.request().method() !== "GET") {
+      await s.fallback();
+      return;
+    }
+    i > 0 && await new Promise((n) => setTimeout(n, i)), await s.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(r)
+    });
+  });
+}
+function q(e) {
+  return `${e.container_id}::${e.id}`;
+}
+function Ge(e) {
+  const o = new URL(e).pathname.split("/cookies/")[1];
+  if (!o)
+    return null;
+  const [a, i] = o.split("/");
+  return !a || !i ? null : { containerId: a, cookieId: i };
+}
+async function je(e) {
+  const { page: t, cookies: o = [pe()] } = e, a = new Map(
+    o.map((i) => [q(i), { ...i }])
+  );
+  await t.route("**/api/v1/**/cookies**", async (i) => {
+    const r = i.request().method();
+    if (r === "GET") {
+      await i.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ data: Array.from(a.values()) })
+      });
+      return;
+    }
+    if (r === "PUT" || r === "POST" || r === "PATCH") {
+      const s = Ge(i.request().url()), n = i.request().postDataJSON();
+      s && typeof n?.value == "string" && a.set(
+        q({
+          container_id: s.containerId,
+          id: s.cookieId
+        }),
+        {
+          container_id: s.containerId,
+          id: s.cookieId,
+          value: n.value
+        }
+      ), await i.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ data: {} })
+      });
+      return;
+    }
+    if (r === "DELETE") {
+      await i.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ data: {} })
+      });
+      return;
+    }
+    await i.fallback();
+  });
+}
+async function ee(e) {
+  const { page: t, locale: o } = e, a = {
+    data: ye(o)
+  };
+  await t.route("**/api/v1/**/na/locales", async (i) => {
+    if (i.request().method() !== "POST") {
+      await i.fallback();
+      return;
+    }
+    await i.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(a)
+    });
+  });
+}
+const $e = "1";
+async function Ve(e) {
+  const { page: t, menuData: o = [], accountMenuData: a } = e;
+  await t.route("**/api/v1/**/menus**", async (i) => {
+    const r = i.request();
+    if (r.method() !== "GET") {
+      await i.fallback();
+      return;
+    }
+    const s = new URL(r.url()).searchParams.get("position"), n = a !== void 0 && s === $e;
+    await i.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({ data: n ? a : o })
+    });
+  });
+}
+async function F(e) {
+  const { page: t, moduleId: o, moduleDictionary: a, isAuth: i = !1 } = e, r = C({
+    data: a?.data,
+    sections: Object.fromEntries(
+      Object.entries(a ?? {}).filter(([n]) => n !== "data")
+    )
+  }), s = i ? "dictionaries" : "na/dictionaries";
+  await t.route(`**/api/v1/**/${s}/${o}**`, async (n) => {
+    if (n.request().method() !== "GET") {
+      await n.fallback();
+      return;
+    }
+    await n.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(r)
+    });
+  });
+}
+async function qe(e) {
+  const { page: t, userPreferences: o, status: a = 200, delayMs: i = 0 } = e, r = {
+    data: be(o)
+  };
+  await t.route("**/api/v1/**/users/me/preferences**", async (s) => {
+    if (s.request().method() !== "GET") {
+      await s.fallback();
+      return;
+    }
+    i > 0 && await new Promise((n) => setTimeout(n, i)), await s.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(r)
+    });
+  });
+}
+const Ye = `
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+  <rect width="16" height="16" fill="#10233e" />
+  <circle cx="8" cy="8" r="4" fill="#f5f7fa" />
+</svg>`, Ke = Buffer.from(
+  "R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==",
+  "base64"
+);
+function We(e) {
+  return [
+    e.assetLogoUrl,
+    e.assetUserInterfaceLogoUrl,
+    e.assetDocumentsLogoUrl,
+    e.assetNotificationsLogoUrl,
+    e.assetLoginBackgroundUrl,
+    e.assetFaviconUrl,
+    e.assetLogoMobileUrl
+  ].filter(Boolean);
+}
+async function te(e) {
+  const { page: t, uiConfig: o } = e, a = W(o);
+  await Promise.all(
+    We(a).map(async (i) => {
+      await t.route(`**/api/v1/main/na/${i}`, async (r) => {
+        const s = i.endsWith(".svg");
+        await r.fulfill({
+          status: 200,
+          contentType: s ? "image/svg+xml" : "image/gif",
+          body: s ? Ye : Ke
+        });
+      });
+    })
+  );
+}
+async function oe(e) {
+  const { page: t, uiConfig: o, status: a = 200, delayMs: i = 0, responseGate: r } = e, s = "**/api/v1/main/na/ui-config/**", n = {
+    data: W(o)
+  };
+  await t.unroute(s), await t.route(s, async (l) => {
+    if (l.request().method() !== "GET") {
+      await l.fallback();
+      return;
+    }
+    r && await r, i > 0 && await new Promise((p) => setTimeout(p, i)), await l.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(a >= 400 ? { error: { code: a, message: "UI config error" } } : n)
+    });
+  });
+}
+async function ze(e) {
+  const {
+    page: t,
+    moduleId: o,
+    accountMenuData: a,
+    areas: i,
+    cookies: r,
+    locale: s,
+    menuData: n,
+    moduleDictionary: l,
+    session: p,
+    uiConfig: y,
+    uiConfigRouteOptions: f,
+    userPreferences: m
+  } = e;
+  await oe({
+    page: t,
+    uiConfig: y,
+    ...f
+  }), await te({
+    page: t,
+    uiConfig: y
+  }), await Ne({
+    page: t,
+    session: p
+  }), await ee({
+    page: t,
+    locale: s
+  }), await qe({
+    page: t,
+    userPreferences: m
+  }), await F({
+    page: t,
+    moduleId: o,
+    moduleDictionary: l,
+    isAuth: !0
+  }), await xe({
+    page: t,
+    areas: i
+  }), await je({
+    page: t,
+    cookies: r
+  }), await Ve({
+    page: t,
+    menuData: n,
+    ...a === void 0 ? {} : { accountMenuData: a }
+  });
+}
+const Je = "platform", Xe = C({
+  data: {
+    module_name: "Platform Shell",
+    module_description: "Authenticated host shell baseline",
+    label_db_type_main: "Main DB",
+    label_db_type_admin: "Admin DB",
+    label_db_type_operative: "Operative DB"
+  }
+});
+async function Qe(e) {
+  const {
+    page: t,
+    moduleId: o,
+    title: a,
+    debugPort: i,
+    iconUrl: r,
+    dynamicParams: s,
+    uiConfig: n,
+    locale: l,
+    session: p,
+    userPreferences: y,
+    moduleDictionary: f,
+    areas: m,
+    cookies: d,
+    hostModuleId: u = Je,
+    alarmCount: R,
+    menuPosition: A = "sidebar"
+  } = e, c = le({
+    moduleId: o,
+    title: a,
+    debugPort: i,
+    ...r ? { iconUrl: r } : {},
+    ...s ? { dynamicParams: s } : {}
+  }), b = c.flatMap((w) => w.children ?? []), E = A === "account";
+  await ze({
+    page: t,
+    moduleId: u,
+    uiConfig: n,
+    locale: l,
+    session: p,
+    userPreferences: y,
+    moduleDictionary: f ?? Xe,
+    areas: m,
+    cookies: d,
+    menuData: E ? [] : c,
+    ...E ? { accountMenuData: b } : {}
+  }), await Ue({
+    page: t,
+    ...R === void 0 ? {} : { count: R }
+  });
+}
+const Ze = "hostRuntimeDummyPresetId", et = "hostRuntimeMode";
+function tt(e, t) {
+  const o = typeof t?.dummyPresetId == "string" ? t.dummyPresetId.trim() : "";
+  if (!o)
+    return e;
+  const a = new URL(e, "https://host-preview.local");
+  return o && (a.searchParams.set(et, "dummy"), a.searchParams.set(Ze, o)), `${a.pathname}${a.search}${a.hash}`;
+}
+const ot = 6e4, at = 2e3, it = 250;
+async function rt(e) {
+  const { debugPort: t, page: o } = e, a = `https://localhost:${t}/`, i = Date.now();
+  let r = null;
+  for (; Date.now() - i < ot; ) {
+    try {
+      const s = await o.request.get(a, {
+        failOnStatusCode: !1,
+        timeout: at
+      });
+      if (s.status() < 500)
+        return;
+      r = new Error(
+        `Preview debug port ${t} responded with status ${s.status()}.`
+      );
+    } catch (s) {
+      r = s;
+    }
+    await o.waitForTimeout(it);
+  }
+  throw new Error(
+    `Timed out waiting for preview debug port ${t} at ${a} to become ready.${r instanceof Error ? ` Last error: ${r.message}` : ""}`
+  );
+}
+async function To(e) {
+  const {
+    page: t,
+    moduleId: o,
+    title: a,
+    debugPort: i,
+    iconUrl: r,
+    dynamicParams: s,
+    initialPath: n = "/",
+    exact: l,
+    toggleSelector: p,
+    installPostMountRoutes: y,
+    waitForModuleOpen: f,
+    maxSidebarClickAttempts: m,
+    skipDebugPortReadyWait: d = !1,
+    ...u
+  } = e, R = tt(n, s), A = performance.now(), c = performance.now();
+  await Qe({
+    page: t,
+    moduleId: o,
+    title: a,
+    debugPort: i,
+    ...r ? { iconUrl: r } : {},
+    ...s ? { dynamicParams: s } : {},
+    ...u
+  });
+  const b = performance.now() - c, E = performance.now();
+  await y?.(t);
+  const w = performance.now() - E;
+  d || await rt({ debugPort: i, page: t });
+  const D = performance.now();
+  await t.goto(R);
+  const L = performance.now() - D, O = await Be({
+    page: t,
+    moduleTitle: a,
+    exact: l,
+    maxClickAttempts: m,
+    toggleSelector: p,
+    waitForModuleOpen: f
+  });
+  return {
+    gotoMs: L,
+    installBootstrapMs: b,
+    installPostMountRoutesMs: w,
+    sidebarClickAttempts: O.clickAttempts,
+    sidebarOpenMs: O.totalMs,
+    sidebarToggleUsed: O.toggleUsed,
+    totalMs: performance.now() - A
+  };
+}
+function st(e) {
+  return Object.freeze({
+    ...e,
+    carrier: "symbol",
+    key: `Symbol.for('${e.symbolId}')`,
+    symbol: Symbol.for(e.symbolId)
+  });
+}
+function g(e) {
+  return Object.freeze({
+    ...e,
+    carrier: "globalThis",
+    key: `globalThis.${e.property}`
+  });
+}
+function H(e) {
+  return Object.freeze({
+    ...e,
+    carrier: "window",
+    key: `window.${e.property}`
+  });
+}
+const nt = st({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "packages/layouts/src/utils/mfRuntimeErrors.ts"
+  ],
+  docsPath: "docs/frontend/observability/FRONTEND_OBSERVABILITY_ARCHITECTURE.md",
+  id: "layouts.mf-runtime-errors",
+  introducedOn: "2026-05-06",
+  kind: "symbol-bridge",
+  lifecycle: "production",
+  namingStatus: "canonical",
+  objective: "Preserve MF runtime-boundary crash forwarding even when the host shell and the MF ship different bundled copies of @m4l/layouts.",
+  ownerProject: "@m4l/layouts",
+  purpose: "Share one host-owned MF runtime error bridge across separately built bundles.",
+  stability: "internal",
+  symbolId: "m4l.layouts.mfRuntimeErrors"
+}), ct = g({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "packages/realtime-runtime/src/engine/runtimeRegistry.ts"
+  ],
+  docsPath: "packages/realtime-runtime/README.md",
+  id: "realtime.runtime-registry",
+  introducedOn: "2026-04-27",
+  kind: "global-registry",
+  lifecycle: "production",
+  namingStatus: "canonical",
+  objective: "Reuse one host-owned realtime runtime instance per runtime key instead of re-creating overlapping transports and stores.",
+  ownerProject: "@m4l/realtime-runtime",
+  property: "__M4L_REALTIME_RUNTIMES__",
+  purpose: "Store the shared realtime runtime registry for the current browser session.",
+  stability: "internal"
+}), ae = g({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "packages/gclick-realtime/src/shared/performanceMetrics.ts",
+    "packages/gclick-realtime/src/web/diagnostics/performanceMetrics.ts",
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/map-shell/observability/realtimePerformanceDebug.ts"
+  ],
+  docsPath: "packages/gclick/README.md",
+  id: "realtime.performance-debug",
+  introducedOn: "2026-05-06",
+  kind: "global-registry",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Expose one browser-readable performance bag so realtime rendering, queue pressure, and interpolation diagnostics can be inspected without instrumenting every consumer separately.",
+  ownerProject: "@m4l/gclick-realtime",
+  property: "__M4L_REALTIME_PERFORMANCE__",
+  purpose: "Publish shared realtime performance counters and motion metrics for browser inspection.",
+  stability: "internal"
+}), lt = g({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "apps/gclick/gclick_host/src/observability/host/realtime.ts",
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/realtime.ts"
+  ],
+  docsPath: "packages/realtime-runtime/README.md",
+  id: "realtime.transport-debug",
+  introducedOn: "2026-08-20",
+  kind: "global-registry",
+  lifecycle: "production",
+  namingStatus: "canonical",
+  objective: "Keep a bounded browser-readable Atmosphere lifecycle buffer only while a remote diagnostic policy is active.",
+  ownerProject: "@m4l/gclick-realtime",
+  property: "__M4L_REALTIME_TRANSPORT_DEBUG__",
+  purpose: "Expose recent Atmosphere lifecycle breadcrumbs for support debugging in host and isolation browser sessions.",
+  stability: "operator-facing"
+}), dt = H({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "apps/gclick/gclick_host/src/observability/dev/smoke.ts",
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/smoke.ts"
+  ],
+  docsPath: "apps/gclick/gclick_host/README.md",
+  id: "observability.smoke-tools",
+  introducedOn: "2026-05-06",
+  kind: "window-tool",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Give browser operators one predictable console namespace that can emit synthetic telemetry and, when needed in preview or local diagnostics, request one intentional host-loaded MF boundary crash.",
+  ownerProject: "@m4l/gclick_host",
+  property: "__m4lObservabilitySmoke",
+  purpose: "Expose browser-console observability smoke helpers for host, preview, and isolation validation.",
+  stability: "operator-facing"
+}), ut = H({
+  active: !0,
+  cleanup: "on-unmount",
+  codeRefs: [
+    "apps/gclick/gclick_host/src/layouts/PlatformLayout/dev/installHostRealtimeAlarmSmokeTools.ts"
+  ],
+  docsPath: "apps/gclick/gclick_host/README.md",
+  id: "host.alarm-smoke-tools",
+  introducedOn: "2026-06-17",
+  kind: "window-tool",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Provide one operator-facing bridge for emitting synthetic rt_alarms traffic while keeping the cleanup contract tied to the host shell lifecycle.",
+  ownerProject: "@m4l/gclick_host",
+  property: "__m4lHostAlarmSmoke",
+  purpose: "Publish host alarm smoke helpers for manual badge and websocket validation.",
+  stability: "operator-facing"
+}), pt = g({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/map-surface/clusterPolicy/DeviceClusterPolicyController/helpers.ts"
+  ],
+  id: "gps-devices.cluster-policy-debug",
+  introducedOn: "2026-05-04",
+  kind: "global-registry",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Explain the effective clustering mode from the live browser session without reverse-engineering the viewport heuristics after the fact.",
+  ownerProject: "@m4l/operative_my_gps_devices",
+  property: "__M4L_GPS_DEVICES_CLUSTER_POLICY__",
+  purpose: "Publish the latest device-cluster policy snapshot for browser debugging and probes.",
+  stability: "internal"
+}), mt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/map-surface/MapContent/helpers/viewportTrace.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices/docs/07-observability-and-debugging.md",
+  id: "gps-devices.viewport-trace",
+  introducedOn: "2026-05-20",
+  kind: "global-registry",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Keep one bounded browser-readable trace buffer so viewport follow decisions can be inspected after the interaction that produced them.",
+  ownerProject: "@m4l/operative_my_gps_devices",
+  property: "__M4L_GPS_DEVICES_VIEWPORT_TRACE__",
+  purpose: "Store the current viewport trace buffer for manual debugging and browser probes.",
+  stability: "internal"
+}), gt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/map-surface/MapContent/helpers/viewportTrace.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices/docs/07-observability-and-debugging.md",
+  id: "gps-devices.viewport-trace-enabled",
+  introducedOn: "2026-05-20",
+  kind: "global-registry",
+  lifecycle: "preview-dev",
+  namingStatus: "canonical",
+  objective: "Allow narrow browser sessions to opt into viewport-trace publication without paying the cost or noise in every runtime by default.",
+  ownerProject: "@m4l/operative_my_gps_devices",
+  property: "__M4L_GPS_DEVICES_VIEWPORT_TRACE_ENABLED__",
+  purpose: "Toggle viewport trace publication for the current browser session.",
+  stability: "internal"
+}), yt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/device-panel/hydration/testDriver.ts"
+  ],
+  id: "gps-devices.device-panel-hydration-driver",
+  introducedOn: "2026-05-28",
+  kind: "test-driver",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Let deterministic browser contracts force hydration edge cases without mutating the production store or backend contracts.",
+  ownerProject: "@m4l/operative_my_gps_devices",
+  property: "__M4L_TEST_DEVICE_PANEL_HYDRATION_DRIVER__",
+  purpose: "Expose the device-panel hydration test driver for deterministic browser tests.",
+  stability: "test-only"
+}), ft = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/features/markers/DeviceMarker/helpers/browserVisibilityLifecycle.helpers.ts"
+  ],
+  id: "gps-devices.document-visibility-driver",
+  introducedOn: "2026-04-29",
+  kind: "test-driver",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Drive hidden-tab resume behavior deterministically in browser probes where headless Chromium cannot guarantee the real background-tab lifecycle.",
+  ownerProject: "@m4l/operative_my_gps_devices",
+  property: "__M4L_TEST_DOCUMENT_VISIBILITY_DRIVER__",
+  purpose: "Expose the document-visibility test driver for deterministic lifecycle tests.",
+  stability: "test-only"
+}), bt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/src/realtimeProbe/hiddenTabResume/collectHiddenTabResumeProbeReport.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/README.md",
+  id: "gps-devices.hidden-tab-visibility-shim",
+  introducedOn: "2026-05-01",
+  kind: "test-driver",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Wrap the product-owned document visibility driver behind one stable probe-local shim so hidden-tab resume probes can drive lifecycle transitions without duplicating browser-specific logic in every step.",
+  ownerProject: "@m4l/operative_my_gps_devices-e2e",
+  property: "__M4L_TEST_VISIBILITY_SHIM__",
+  purpose: "Expose the hidden-tab resume visibility shim for deterministic Playwright probes.",
+  stability: "test-only"
+}), wt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/src/realtimeProbe/hiddenTabResume/collectHiddenTabResumeProbeReport.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/README.md",
+  id: "gps-devices.hidden-tab-dummy-playback-shim",
+  introducedOn: "2026-05-01",
+  kind: "test-driver",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Wrap the shared dummy playback driver behind one probe-local seam so hidden-tab resume contracts can pause and resume emissions without coupling every probe step to the underlying runtime implementation.",
+  ownerProject: "@m4l/operative_my_gps_devices-e2e",
+  property: "__M4L_TEST_DUMMY_PLAYBACK_SHIM__",
+  purpose: "Expose the hidden-tab resume dummy playback shim for deterministic Playwright probes.",
+  stability: "test-only"
+}), ht = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/src/realtimeProbe/nonSelectedViewportGate/runNonSelectedViewportGateProbe.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/README.md",
+  id: "gps-devices.non-selected-viewport-gate-zoom-settle",
+  introducedOn: "2026-05-01",
+  kind: "global-registry",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Persist the short-lived zoom-settlement clock across repeated browser polling calls so the deep viewport-gate probe can prove a stable ring transition after standalone bootstrap normalization.",
+  ownerProject: "@m4l/operative_my_gps_devices-e2e",
+  property: "__M4L_NON_SELECTED_VIEWPORT_GATE_ZOOM_SETTLE__",
+  purpose: "Store the non-selected viewport-gate probe zoom settlement state for the current browser session.",
+  stability: "test-only"
+}), vt = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/src/realtimeProbe/sparseRotation/collectSparseRotationProbeReport.ts"
+  ],
+  docsPath: "apps/gclick/mfs/operative/operative_my_gps_devices-e2e/README.md",
+  id: "gps-devices.sparse-rotation-stationary-wait",
+  introducedOn: "2026-05-16",
+  kind: "global-registry",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Persist the stationary-window sampling state across browser polling cycles so the sparse-rotation probe can detect the deterministic pause window without leaking that bookkeeping into product runtime code.",
+  ownerProject: "@m4l/operative_my_gps_devices-e2e",
+  property: "__M4L_SPARSE_ROTATION_STATIONARY_WAIT__",
+  purpose: "Store the sparse-rotation stationary wait state for the current browser session.",
+  stability: "test-only"
+}), _t = g({
+  active: !0,
+  cleanup: "manual",
+  codeRefs: [
+    "packages/gclick-realtime/src/dummy/runtime/dummy.ts"
+  ],
+  id: "gclick-realtime.dummy-playback-driver",
+  introducedOn: "2026-02-19",
+  kind: "test-driver",
+  lifecycle: "test-only",
+  namingStatus: "canonical",
+  objective: "Provide a deterministic browser-global seam for pausing and resuming dummy playback while leaving the runtime implementation itself bundle-local.",
+  ownerProject: "@m4l/gclick-realtime",
+  property: "__M4L_TEST_DUMMY_PLAYBACK_DRIVER__",
+  purpose: "Expose the dummy realtime playback driver for deterministic browser probes and tests.",
+  stability: "test-only"
+}), kt = H({
+  active: !0,
+  cleanup: "none",
+  codeRefs: [
+    "packages/gclick/src/components/maps/components/GpsMap/subcomponents/TileLayers/subcomponents/TileLayerGoogle/googleMapsLoader.ts"
+  ],
+  id: "gclick.google-maps-loader-state",
+  introducedOn: "2026-05-15",
+  kind: "global-registry",
+  lifecycle: "production",
+  namingException: "Legacy Google Maps loader state predates the canonical global-registry naming shape and still uses one lower-camel window key for backwards compatibility.",
+  namingStatus: "legacy-exception",
+  objective: "Coordinate one in-page Google Maps JavaScript loader promise across bundles so repeated map mounts do not race or reload the SDK.",
+  ownerProject: "@m4l/gclick",
+  property: "__m4lGoogleMapsLoaderState__",
+  purpose: "Store the shared Google Maps loader state for the current browser window.",
+  stability: "internal"
+}), B = [
+  nt,
+  ct,
+  ae,
+  lt,
+  dt,
+  ut,
+  pt,
+  mt,
+  gt,
+  yt,
+  ft,
+  bt,
+  wt,
+  ht,
+  vt,
+  _t,
+  kt
+];
+function Rt(e) {
+  const t = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+  for (const a of e) {
+    if (t.has(a.id))
+      throw new Error(`Duplicate browser runtime handle id "${a.id}".`);
+    if (t.add(a.id), o.has(a.key))
+      throw new Error(`Duplicate browser runtime handle key "${a.key}".`);
+    o.add(a.key);
+  }
+}
+Rt(B);
+Object.freeze(
+  Object.fromEntries(
+    B.map((e) => [e.id, e])
+  )
+);
+Object.freeze(
+  Object.fromEntries(
+    B.map((e) => [e.key, e])
+  )
+);
+const v = "gclick-frontend-diagnostic-policies", _ = [
+  "moduleDefault",
+  "accountOverride"
+], S = {
+  app: "gclick_host",
+  runtime: "web",
+  surface: "host"
+}, Et = {
+  diagnosticSmoke: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/dev/smoke.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-06-05",
+    id: "gclickHostDiagnosticSmoke",
+    key: "gclick_host.observability.diagnostic-smoke",
+    notes: [
+      "This family is primarily exercised through the browser smoke helper and support overrides."
+    ],
+    owner: S,
+    purpose: "Provide one deterministic browser-log smoke signal before support investigates a live issue.",
+    summary: "Manual host smoke proof for browser diagnostic-log delivery.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "gclick_host.observability.diagnostic-smoke",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  realtimeConnectionRecovery: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/host/realtime.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-06-05",
+    id: "gclickHostRealtimeConnectionRecovery",
+    key: "gclick_host.realtime.connection-recovery",
+    owner: S,
+    purpose: "Capture host websocket transport recovery evidence without waiting for a broader outage investigation.",
+    summary: "Host realtime reconnect recovery breadcrumbs.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "gclick_host.realtime.connection-recovery",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  realtimeTransportLifecycle: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/host/realtime.ts",
+      "apps/gclick/gclick_host/src/layouts/PlatformLayout/helpers/createAtmosphereHostRealtimeRuntime.ts",
+      "packages/realtime-runtime/src/transport/atmosphere/web/SourceDataAtmosphereWeb.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-08-20",
+    id: "gclickHostRealtimeTransportLifecycle",
+    key: "gclick_host.realtime.transport-lifecycle",
+    owner: S,
+    purpose: "Capture host Atmosphere lifecycle breadcrumbs during temporary support investigations of reconnect storms and browser sleep recovery.",
+    summary: "Host Atmosphere transport lifecycle breadcrumbs.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "gclick_host.realtime.transport-lifecycle",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  remoteDiagnosticProviderHealth: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/diagnostic/diagnosticFeatureFlags.ts"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-06-08",
+    id: "gclickHostRemoteDiagnosticProviderHealth",
+    key: "gclick_host.feature-flags.remote-diagnostic-provider-health",
+    notes: [
+      "This family is intentionally always-on because provider outages are recoverable anomalies, not optional debug breadcrumbs."
+    ],
+    owner: S,
+    purpose: "Report the first failure in a remote diagnostic-provider outage streak even when no support capture is active.",
+    summary: "Host remote diagnostic-provider outage anomaly."
+  },
+  tracesRelayDisabled: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/otlp/client.ts",
+      "apps/gclick/gclick_host/src/observability/otlp/relayDiagnostics.ts",
+      "libs/observability/web/src/browserOtlp.ts"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-06-16",
+    id: "gclickHostTracesRelayDisabled",
+    key: "gclick_host.observability.traces-relay-disabled",
+    notes: [
+      "This family is intentionally always-on because once the browser traces relay disables itself, trace traffic becomes silent and support needs one surviving breadcrumb in Grafana logs."
+    ],
+    owner: S,
+    purpose: "Report the first permanent browser traces-relay shutdown together with the failure metadata that caused the relay to stop exporting.",
+    summary: "Host browser traces-relay shutdown anomaly."
+  },
+  runtimeBoundaryCrash: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/host/runtimeErrors.ts",
+      "packages/layouts/src/components/MFHostApp/MFHostAppErrorBoundary.tsx",
+      "packages/layouts/src/components/MFRuntimeErrorWrapper/MFRuntimeErrorWrapper.tsx",
+      "apps/gclick/gclick_host/src/components/HostShellErrorBoundary/HostShellErrorBoundary.tsx"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-06-14",
+    id: "gclickHostRuntimeBoundaryCrash",
+    key: "gclick_host.runtime-errors.boundary-crash",
+    notes: [
+      "This family is intentionally always-on because React boundary crashes are rare fatal degradations that should remain countable in Grafana logs, not only in traces.",
+      "Host-loaded MF wrapper boundaries reuse this family with `runtime.boundary_scope=wrapper` and a stable `runtime.wrapper_id` so support can group contained subtree crashes without a separate policy."
+    ],
+    owner: S,
+    purpose: "Report contained host-shell and host-loaded MF boundary crashes as structured always-on diagnostic logs for dashboarding and alerting.",
+    summary: "Host boundary crash anomaly for host shell and host-loaded MFs."
+  },
+  refreshDebug: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/gclick_host/src/observability/diagnostic/diagnosticFeatureFlags.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-06-11",
+    id: "gclickHostRefreshDebug",
+    key: "gclick_host.feature-flags.refresh-debug",
+    notes: [
+      "Use this family when support needs to understand why the browser refreshed, queued, or applied one remote diagnostic payload."
+    ],
+    owner: S,
+    purpose: "Expose host-owned GrowthBook refresh breadcrumbs such as bootstrap, context, focus, visibility, poll, and queued refreshes.",
+    summary: "Host remote diagnostic-provider refresh debug breadcrumbs.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "gclick_host.feature-flags.refresh-debug",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  }
+}, P = {
+  app: "operative_my_gps_devices",
+  moduleId: "operative_my_gps_devices",
+  runtime: "web",
+  surface: "mf"
+}, St = {
+  deviceSelectionMissingPosition: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/subcomponents/ModuleMap/subcomponents/MapContent/subcomponents/DevicesPanel/subcomponents/DevicesPanelBody/subcomponents/DeviceCard/DeviceCard.tsx"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-06-05",
+    id: "operativeMyGpsDevicesDeviceSelectionMissingPosition",
+    key: "operative_my_gps_devices.device-selection.missing-position",
+    owner: P,
+    purpose: "Capture the user-visible branch where one selected device has no finite GNSS position and the map must skip focus safely.",
+    summary: "MF selection branch for devices without finite GNSS position.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "operative_my_gps_devices.device-selection.missing-position",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  motionCapture: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/subcomponents/ModuleMap/subcomponents/MapContent/subcomponents/DeviceMarker/helpers/motionCapture.ts",
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/smoke.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-06-06",
+    id: "operativeMyGpsDevicesMotionCapture",
+    key: "operative_my_gps_devices.motion.capture",
+    notes: [
+      "The closing session summary is treated as the final record of a policy-authorized capture session, not as a separate always-on anomaly lane."
+    ],
+    owner: P,
+    purpose: "Capture selected-device realtime ingress, motion-segment, and camera-follow evidence for support investigations.",
+    summary: "MF targeted motion-capture diagnostic family.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "operative_my_gps_devices.motion.capture",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  realtimeTransportLifecycle: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/helpers/createIsolationHostRuntime.ts",
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/realtime.ts",
+      "packages/realtime-runtime/src/transport/atmosphere/web/SourceDataAtmosphereWeb.ts"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-08-20",
+    id: "operativeMyGpsDevicesRealtimeTransportLifecycle",
+    key: "operative_my_gps_devices.realtime.transport-lifecycle",
+    owner: P,
+    purpose: "Capture isolation Atmosphere lifecycle breadcrumbs during temporary support investigations of reconnect storms and browser sleep recovery.",
+    summary: "My GPS Devices isolation Atmosphere transport lifecycle breadcrumbs.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "operative_my_gps_devices.realtime.transport-lifecycle",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  recoverableLeafletRuntime: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/subcomponents/ModuleMap/subcomponents/MapContent/subcomponents/DeviceMarker/helpers/reportLeafletRuntimeError.ts"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-06-05",
+    id: "operativeMyGpsDevicesRecoverableLeafletRuntime",
+    key: "operative_my_gps_devices.recoverable.leaflet-runtime",
+    owner: P,
+    purpose: "Expose recovered Leaflet runtime anomalies that should never stay silent even without one active support capture.",
+    summary: "MF always-on recovered Leaflet runtime anomaly."
+  },
+  remoteDiagnosticProviderHealth: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/diagnosticFeatureFlags.ts"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-06-08",
+    id: "operativeMyGpsDevicesRemoteDiagnosticProviderHealth",
+    key: "operative_my_gps_devices.feature-flags.remote-diagnostic-provider-health",
+    owner: P,
+    purpose: "Report isolation remote diagnostic-provider outages even when the active session has no support policy enabled.",
+    summary: "MF isolation remote diagnostic-provider outage anomaly."
+  }
+}, Y = {
+  app: "shared_reports_list",
+  moduleId: "shared_reports_list",
+  runtime: "web",
+  surface: "mf"
+}, Tt = {
+  reportsDebug: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/shared/shared_reports_list/src/components/App/context/ReportContext"
+    ],
+    controlPlane: "remote-policy",
+    createdAt: "2026-08-22",
+    id: "sharedReportsListReportsDebug",
+    key: "shared_reports_list.feature-flags.reports-debug",
+    notes: [
+      "Fallback product gate hosted in observability only because a dedicated product feature-flag library was not approved.",
+      "This policy must not be used to emit diagnostic logs; shared_reports_list reads only isEnabled(key).",
+      "Migrate to a product feature-flag library when that boundary becomes available."
+    ],
+    owner: Y,
+    purpose: "Allow support-enabled sessions to remove the reports/types test-worker exclusion filter.",
+    summary: "Fallback product gate for the shared reports test report type.",
+    remoteRule: {
+      featureKey: v,
+      payloadKey: "shared_reports_list.feature-flags.reports-debug",
+      provider: "growthbook",
+      supportedLayers: _
+    }
+  },
+  remoteDiagnosticProviderHealth: {
+    active: !0,
+    codePaths: [
+      "apps/gclick/mfs/shared/shared_reports_list/src/components/appEntries/ByIsolation/observability/diagnosticFeatureFlags.ts"
+    ],
+    controlPlane: "always-on",
+    createdAt: "2026-08-24",
+    id: "sharedReportsListRemoteDiagnosticProviderHealth",
+    key: "shared_reports_list.feature-flags.remote-diagnostic-provider-health",
+    owner: Y,
+    purpose: "Report isolation remote diagnostic-provider outages even when report debug is disabled.",
+    summary: "MF isolation remote diagnostic-provider outage anomaly."
+  }
+}, At = [
+  ...Object.values(Et),
+  ...Object.values(St),
+  ...Object.values(Tt)
+];
+Object.fromEntries(
+  At.map((e) => [e.key, e])
+);
+const Ao = ae.property;
+function Po(e) {
+  return globalThis[e.realtimePerformanceProperty]?.motionMetrics?.motionAuthority ?? null;
+}
+function Mo(e) {
+  const a = globalThis[e.realtimePerformanceProperty]?.motionMetrics?.motionAuthority?.markerContexts ?? {};
+  return e.deviceIds.every((i) => !!a[i]);
+}
+function Do(e) {
+  const t = globalThis, a = t[e.realtimePerformanceProperty]?.motionMetrics?.motionAuthority?.markerContexts?.[e.deviceId] ?? null, i = String(t.document?.body?.innerText ?? "");
+  return a?.selected === !0 || i.includes("Last Report");
+}
+function Lo(e) {
+  return (globalThis[e.realtimePerformanceProperty]?.motionMetrics?.motionAuthority?.markerContexts?.[e.deviceId] ?? null)?.selected === !0;
+}
+async function Pt(e, t) {
+  const { arg: o, pageFunction: a, timeoutMs: i } = t;
+  return e.waitForFunction.bind(e)(a, o, { timeout: i }).then(() => !0).catch(() => !1);
+}
+async function Oo(e, t) {
+  const { timeoutMessage: o, ...a } = t;
+  if (!await Pt(e, a))
+    throw new Error(o);
+}
+async function Co(e) {
+  const { page: t, moduleId: o, ...a } = e;
+  await F({
+    page: t,
+    moduleId: o,
+    isAuth: !0,
+    moduleDictionary: ne(a)
+  });
+}
+async function Mt(e) {
+  const { page: t, responseBody: o, status: a = 401 } = e, i = me(o);
+  await t.route("**/api/v1/**/auth/login**", async (r) => {
+    if (r.request().method() !== "GET") {
+      await r.fallback();
+      return;
+    }
+    await r.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(i)
+    });
+  });
+}
+async function Io(e) {
+  const { page: t, moduleId: o, moduleDictionary: a, locale: i, uiConfig: r, uiConfigRouteOptions: s } = e;
+  await oe({
+    page: t,
+    uiConfig: r,
+    ...s
+  }), await te({
+    page: t,
+    uiConfig: r
+  }), await Mt({
+    page: t
+  }), await ee({
+    page: t,
+    locale: i
+  }), await F({
+    page: t,
+    moduleId: o,
+    moduleDictionary: a
+  });
+}
+const Dt = {
+  data: "ok"
+}, Lt = {
+  error: {
+    code: 4200,
+    message: "Password update failed"
+  }
+};
+function Ot(e, t) {
+  return t || (e >= 400 ? Lt : Dt);
+}
+async function Fo(e) {
+  const { page: t, responseBody: o, status: a = 201, delayMs: i = 0 } = e;
+  await t.route("**/api/v1/*/auth/password/new", async (r) => {
+    i > 0 && await new Promise((s) => setTimeout(s, i)), await r.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(Ot(a, o))
+    });
+  });
+}
+const Ct = {
+  message: "Password reset email sent"
+}, It = {
+  error: {
+    code: 4100,
+    message: "Password reset failed"
+  }
+};
+function Ft(e, t) {
+  return t || (e >= 400 ? It : Ct);
+}
+async function Ho(e) {
+  const { page: t, responseBody: o, status: a = 200, delayMs: i = 0 } = e;
+  await t.route("**/api/v1/*/auth/password/reset", async (r) => {
+    i > 0 && await new Promise((s) => setTimeout(s, i)), await r.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify(Ft(a, o))
+    });
+  });
+}
+async function Bo(e) {
+  const {
+    page: t,
+    endpointPattern: o,
+    data: a,
+    pagerPage: i = 0,
+    total: r = a.length,
+    status: s = 200
+  } = e;
+  await t.route(o, async (n) => {
+    await n.fulfill({
+      status: s,
+      contentType: "application/json",
+      body: JSON.stringify(re({ data: a, pagerPage: i, total: r }))
+    });
+  });
+}
+async function Uo(e) {
+  const { page: t, privileges: o, status: a = 200 } = e, i = Object.fromEntries(
+    o.map((r) => [r, !0])
+  );
+  await t.route(/\/auth\/login\?[^#]*privileges/, async (r) => {
+    if (r.request().method() !== "GET") {
+      await r.fallback();
+      return;
+    }
+    await r.fulfill({
+      status: a,
+      contentType: "application/json",
+      body: JSON.stringify({ data: i })
+    });
+  });
+}
+const Ht = "__m4lMicrofrontendRenderStubState";
+async function xo(e) {
+  const {
+    page: t,
+    moduleId: o,
+    prefix: a,
+    renderedText: i = `${o} microfrontend stub rendered.`,
+    renderedTestId: r = `mf-stub-${o}`,
+    stateKey: s = Ht
+  } = e;
+  await t.addInitScript(
+    ({ moduleId: n, prefix: l, renderedText: p, renderedTestId: y, stateKey: f }) => {
+      const m = window, d = m[f], u = d && typeof d == "object" ? d : {
+        mountCalls: [],
+        mountFailures: [],
+        renderCalls: [],
+        unmountCalls: []
+      };
+      m[f] = u, Array.isArray(u.mountCalls) || (u.mountCalls = []), Array.isArray(u.mountFailures) || (u.mountFailures = []);
+      function R(c, b = window.performance.now() + 15e3) {
+        const E = document.getElementById(c);
+        if (!E) {
+          if (window.performance.now() >= b) {
+            u.mountFailures.push({
+              containerId: c,
+              moduleId: n
+            });
+            return;
+          }
+          window.setTimeout(() => {
+            R(c, b);
+          }, 50);
+          return;
+        }
+        const w = document.createElement("section"), D = document.createElement("h2"), L = document.createElement("p");
+        w.setAttribute("data-mf-module-id", n), w.setAttribute("data-mf-stub-root", n), w.setAttribute("data-testid", y), D.textContent = p, L.textContent = `Stub render contract satisfied for ${n}.`, w.replaceChildren(D, L), E.replaceChildren(w), u.mountCalls.push({
+          containerId: c,
+          moduleId: n
+        });
+      }
+      const A = (c) => {
+        const b = typeof c.containerId == "string" ? c.containerId : "";
+        u.renderCalls.push({
+          containerId: b,
+          moduleId: n,
+          debugPort: c.environment?.mfProps?.debugPort ?? null,
+          currentLocale: typeof c.currentLocale == "string" ? c.currentLocale : c.currentLocale?.localeString ?? null,
+          emergeType: c.emergeType ?? null,
+          dynamicParams: c.dynamicMFStore?.getState?.().dynamicMFParameters ?? null
+        }), b && R(b);
+      };
+      m[`render_v2_${l}_${n}`] = A, m[`unmount_${l}_${n}`] = (c) => {
+        u.unmountCalls.push(c), document.getElementById(c)?.replaceChildren();
+      };
+    },
+    {
+      moduleId: o,
+      prefix: a,
+      renderedText: i,
+      renderedTestId: r,
+      stateKey: s
+    }
+  );
+}
+export {
+  Le as HOST_MOBILE_NAV_TOGGLE_NAME,
+  yo as LIST_FILTERS_STATE_COOKIE,
+  Qt as LIST_HEADER_POPOVER_BASE_ACTIONS,
+  fo as LIST_SORTS_STATE_COOKIE,
+  Se as applyListFilterAndCaptureRequest,
+  mo as applyListFiltersAndCaptureRequest,
+  wo as applyListSortAndCaptureRequest,
+  xt as attachJson,
+  to as clickListHeaderPopoverAction,
+  oo as closeListHeaderPopover,
+  Pe as closeViewModeSwitcherDataGrid,
+  K as createHostAreaFixture,
+  le as createHostAuthenticatedMfMenuFixture,
+  ne as createHostAuthenticatedMfModuleDictionaryFixture,
+  de as createHostAuthenticatedSessionFixture,
+  pe as createHostCookieFixture,
+  me as createHostGuestSessionFixture,
+  ye as createHostLocaleFixture,
+  Ut as createHostMfPreviewDynamicParamsFixture,
+  C as createHostModuleDictionaryFixture,
+  W as createHostUiConfigFixture,
+  be as createHostUserPreferencesFixture,
+  re as createListResponseFixture,
+  zt as doubleClickListRow,
+  Ae as expectViewModeDataGrid,
+  Yt as formatFailedChecks,
+  io as getAllColumnAlignmentsViewTableDataGrid,
+  ro as getAllColumnKeysViewTableDataGrid,
+  so as getAllFieldKeysViewCardsOrListDataGrid,
+  vo as getAvailableViewModesDataGrid,
+  Xt as getFocusedCellPositionListDataGrid,
+  jt as getFormActionButton,
+  he as getFormActionsContainer,
+  Gt as getFormConfirmDialog,
+  we as getFormContainer,
+  z as getFormField,
+  Vt as getFormSelectOptions,
+  Kt as getListCell,
+  Q as getListColumnHeader,
+  X as getListColumnHeaderButtons,
+  _e as getListColumnKeys,
+  ve as getListColumnWidth,
+  k as getListDataGrid,
+  J as getListDataRows,
+  ke as getListDetailAccordion,
+  Re as getListDetailAccordionRegions,
+  no as getListDetailEmptyState,
+  co as getListDetailField,
+  uo as getListDetailFieldLabels,
+  go as getListFilterFieldNames,
+  M as getListHeaderPopover,
+  eo as getListHeaderPopoverActions,
+  I as getListRow,
+  ho as getListSortFieldNames,
+  Ro as getRenderedRecordsDataGrid,
+  Nt as getToast,
+  Te as getViewModeDataGrid,
+  Mo as hasRealtimeMarkerContexts,
+  ko as hideAllColumnsDataGrid,
+  Ue as installHostAlarmsCountRoute,
+  xe as installHostAreasRoute,
+  ze as installHostAuthenticatedBootstrapRoutes,
+  Co as installHostAuthenticatedMfModuleDictionaryRoute,
+  Qe as installHostAuthenticatedMfPreviewBootstrap,
+  Ne as installHostAuthenticatedSessionRoute,
+  je as installHostCookiesRoute,
+  Io as installHostGuestBootstrapRoutes,
+  Mt as installHostGuestSessionRoute,
+  ee as installHostLocaleRoute,
+  Ve as installHostMenusRoute,
+  F as installHostModuleDictionaryRoute,
+  Fo as installHostPasswordNewRoute,
+  Ho as installHostPasswordResetRoute,
+  te as installHostUiConfigAssetRoutes,
+  oe as installHostUiConfigRoute,
+  qe as installHostUserPreferencesRoute,
+  Bo as installListEndpointRoute,
+  xo as installMicrofrontendRenderStub,
+  Uo as installModulePrivilegesRoute,
+  Lo as isRealtimeDeviceSelected,
+  Do as isRealtimeDeviceSelectedOrDebugPanelVisible,
+  po as loadListDetailLogsAndCaptureRequest,
+  Me as openColumnSettingsDataGrid,
+  $t as openFormSelectAndCaptureRequest,
+  Eo as openHostAccountMenuModule,
+  To as openHostAuthenticatedMfPreviewModule,
+  So as openHostMobileSidebarModule,
+  Be as openHostSidebarModule,
+  Zt as openListHeaderPopover,
+  Wt as openListRowActionsMenu,
+  Z as openViewModeSwitcherDataGrid,
+  Po as readRealtimeMotionAuthorityState,
+  Ao as realtimePerformanceDebugHandleProperty,
+  ao as resizeListColumn,
+  qt as selectFormOption,
+  Jt as selectListRow,
+  _o as switchViewModeDataGrid,
+  lo as toggleListDetailAccordion,
+  Pt as tryWaitForBrowserCondition,
+  Oo as waitForBrowserCondition,
+  bo as waitForListStatePersistence
+};