@m4l/testing 0.0.23 → 1.0.1

package/rtl/index.js

@@ -0,0 +1,180 @@
+import { c as z } from "../chunks/render-CsuV8xqo.js";
+import { vi as i } from "vitest";
+function O(r = {}) {
+  const { width: e = 0, height: t = 0 } = r;
+  return {
+    bottom: t,
+    height: t,
+    left: 0,
+    right: e,
+    toJSON: () => ({}),
+    top: 0,
+    width: e,
+    x: 0,
+    y: 0
+  };
+}
+function v(r, e = {}) {
+  return {
+    borderBoxSize: [],
+    contentBoxSize: [],
+    contentRect: O(e),
+    devicePixelContentBoxSize: [],
+    target: r
+  };
+}
+function h(r = {}) {
+  const { autoTriggerOnObserve: e = !1, createEntries: t } = r, l = globalThis.ResizeObserver, u = typeof window < "u" ? window.ResizeObserver : void 0;
+  let o = null, a = null, s = null;
+  const b = i.fn((n) => {
+    a = n, e && o && o(
+      t?.(n) ?? [v(n)],
+      s
+    );
+  }), f = i.fn((n) => n), w = i.fn();
+  class p {
+    observe(g) {
+      b(g);
+    }
+    unobserve(g) {
+      f(g);
+    }
+    disconnect() {
+      w();
+    }
+    constructor(g) {
+      o = g, s = this;
+    }
+  }
+  return Object.defineProperty(globalThis, "ResizeObserver", {
+    configurable: !0,
+    value: p,
+    writable: !0
+  }), typeof window < "u" && Object.defineProperty(window, "ResizeObserver", {
+    configurable: !0,
+    value: p,
+    writable: !0
+  }), {
+    disconnect: w,
+    observe: b,
+    restore: () => {
+      typeof l > "u" ? delete globalThis.ResizeObserver : Object.defineProperty(globalThis, "ResizeObserver", {
+        configurable: !0,
+        value: l,
+        writable: !0
+      }), typeof window < "u" && (typeof u > "u" ? delete window.ResizeObserver : Object.defineProperty(window, "ResizeObserver", {
+        configurable: !0,
+        value: u,
+        writable: !0
+      })), o = null, a = null, s = null;
+    },
+    trigger: (n) => {
+      o && o(
+        n ?? (a ? [v(a)] : []),
+        s
+      );
+    },
+    unobserve: f
+  };
+}
+function y(r = {}) {
+  const { matches: e = !1 } = r, t = window.matchMedia;
+  beforeAll(() => {
+    Object.defineProperty(window, "matchMedia", {
+      configurable: !0,
+      value: i.fn().mockImplementation((l) => ({
+        matches: e,
+        media: l,
+        onchange: null,
+        addListener: i.fn(),
+        removeListener: i.fn(),
+        addEventListener: i.fn(),
+        removeEventListener: i.fn(),
+        dispatchEvent: i.fn()
+      })),
+      writable: !0
+    });
+  }), afterAll(() => {
+    if (typeof t > "u") {
+      Reflect.deleteProperty(window, "matchMedia");
+      return;
+    }
+    Object.defineProperty(window, "matchMedia", {
+      configurable: !0,
+      value: t,
+      writable: !0
+    });
+  });
+}
+class d {
+  storage = /* @__PURE__ */ new Map();
+  get length() {
+    return this.storage.size;
+  }
+  clear() {
+    this.storage.clear();
+  }
+  getItem(e) {
+    return this.storage.get(e) ?? null;
+  }
+  key(e) {
+    return Array.from(this.storage.keys())[e] ?? null;
+  }
+  removeItem(e) {
+    this.storage.delete(e);
+  }
+  setItem(e, t) {
+    this.storage.set(e, String(t));
+  }
+}
+function c(r, e, t) {
+  if (typeof t > "u") {
+    Reflect.deleteProperty(r, e);
+    return;
+  }
+  Object.defineProperty(r, e, t);
+}
+function P() {
+  const r = new d(), e = new d(), t = Object.getOwnPropertyDescriptor(globalThis, "Storage"), l = Object.getOwnPropertyDescriptor(globalThis, "localStorage"), u = Object.getOwnPropertyDescriptor(globalThis, "sessionStorage"), o = typeof window < "u", a = o ? Object.getOwnPropertyDescriptor(window, "Storage") : void 0, s = o ? Object.getOwnPropertyDescriptor(window, "localStorage") : void 0, b = o ? Object.getOwnPropertyDescriptor(window, "sessionStorage") : void 0;
+  return Object.defineProperty(globalThis, "Storage", {
+    configurable: !0,
+    value: d,
+    writable: !0
+  }), Object.defineProperty(globalThis, "localStorage", {
+    configurable: !0,
+    value: r,
+    writable: !0
+  }), Object.defineProperty(globalThis, "sessionStorage", {
+    configurable: !0,
+    value: e,
+    writable: !0
+  }), o && (Object.defineProperty(window, "Storage", {
+    configurable: !0,
+    value: d,
+    writable: !0
+  }), Object.defineProperty(window, "localStorage", {
+    configurable: !0,
+    value: r,
+    writable: !0
+  }), Object.defineProperty(window, "sessionStorage", {
+    configurable: !0,
+    value: e,
+    writable: !0
+  })), {
+    clear: () => {
+      r.clear(), e.clear();
+    },
+    localStorage: r,
+    restore: () => {
+      c(globalThis, "Storage", t), c(globalThis, "localStorage", l), c(globalThis, "sessionStorage", u), o && (c(window, "Storage", a), c(window, "localStorage", s), c(window, "sessionStorage", b));
+    },
+    sessionStorage: e
+  };
+}
+export {
+  v as createResizeObserverEntry,
+  y as installMatchMediaMock,
+  h as installResizeObserverMock,
+  P as installStorageMock,
+  z as render
+};

package/types/libs/observability/mf/src/browserRuntimeHandles.d.ts

@@ -0,0 +1,112 @@
+export declare const browserRuntimeHandleKinds: readonly ["symbol-bridge", "global-registry", "window-tool", "test-driver"];
+export declare const browserRuntimeHandleCarriers: readonly ["symbol", "globalThis", "window"];
+export declare const browserRuntimeHandleLifecycles: readonly ["production", "preview-dev", "test-only", "storybook"];
+export declare const browserRuntimeHandleNamingStatuses: readonly ["canonical", "legacy-exception"];
+export declare const browserRuntimeHandleStabilities: readonly ["internal", "operator-facing", "test-only"];
+export declare const browserRuntimeHandleCleanupModes: readonly ["none", "on-unmount", "manual"];
+export type BrowserRuntimeHandleKind = typeof browserRuntimeHandleKinds[number];
+export type BrowserRuntimeHandleCarrier = typeof browserRuntimeHandleCarriers[number];
+export type BrowserRuntimeHandleLifecycle = typeof browserRuntimeHandleLifecycles[number];
+export type BrowserRuntimeHandleNamingStatus = typeof browserRuntimeHandleNamingStatuses[number];
+export type BrowserRuntimeHandleStability = typeof browserRuntimeHandleStabilities[number];
+export type BrowserRuntimeHandleCleanup = typeof browserRuntimeHandleCleanupModes[number];
+/**
+ * Shared metadata for one governed browser runtime handle.
+ *
+ * `id` is the stable catalog name used by docs, validation, and cross-module
+ * references. It is intentionally distinct from the concrete runtime lookup
+ * path because a handle may keep the same logical purpose even if its browser
+ * storage mechanism changes over time.
+ */
+interface BrowserRuntimeHandleBaseDefinition {
+    active: boolean;
+    cleanup: BrowserRuntimeHandleCleanup;
+    codeRefs: string[];
+    docsPath?: string;
+    /** Stable catalog identifier. This is the governance name, not the JS lookup path. */
+    id: string;
+    introducedBy?: string;
+    introducedOn: string;
+    kind: BrowserRuntimeHandleKind;
+    lifecycle: BrowserRuntimeHandleLifecycle;
+    namingException?: string;
+    namingStatus: BrowserRuntimeHandleNamingStatus;
+    objective: string;
+    ownerProject: string;
+    purpose: string;
+    stability: BrowserRuntimeHandleStability;
+}
+export interface BrowserRuntimeSymbolHandleDefinition<TSymbolId extends string = string> extends BrowserRuntimeHandleBaseDefinition {
+    /** Browser-owned container that stores the live handle. */
+    carrier: 'symbol';
+    /** Exact runtime lookup address derived from the carrier-specific token. */
+    key: `Symbol.for('${TSymbolId}')`;
+    symbol: symbol;
+    /** Carrier-specific token used to recreate the shared `Symbol.for(...)` entry. */
+    symbolId: TSymbolId;
+}
+export interface BrowserRuntimeGlobalThisHandleDefinition<TProperty extends string = string> extends BrowserRuntimeHandleBaseDefinition {
+    /** Browser-owned container that stores the live handle. */
+    carrier: 'globalThis';
+    /** Exact runtime lookup address derived from the carrier-specific property name. */
+    key: `globalThis.${TProperty}`;
+    /** Carrier-specific property name published on `globalThis`. */
+    property: TProperty;
+}
+export interface BrowserRuntimeWindowHandleDefinition<TProperty extends string = string> extends BrowserRuntimeHandleBaseDefinition {
+    /** Browser-owned container that stores the live handle. */
+    carrier: 'window';
+    /** Exact runtime lookup address derived from the carrier-specific property name. */
+    key: `window.${TProperty}`;
+    /** Carrier-specific property name published on `window`. */
+    property: TProperty;
+}
+export type BrowserRuntimeHandleDefinition = BrowserRuntimeSymbolHandleDefinition | BrowserRuntimeGlobalThisHandleDefinition | BrowserRuntimeWindowHandleDefinition;
+export declare const layoutsMfRuntimeErrorsHandle: Readonly<BrowserRuntimeSymbolHandleDefinition<"m4l.layouts.mfRuntimeErrors">>;
+export declare const realtimeRuntimeRegistryHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_RUNTIMES__">>;
+export declare const realtimePerformanceDebugHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_PERFORMANCE__">>;
+export declare const realtimeTransportDebugHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_TRANSPORT_DEBUG__">>;
+export declare const observabilitySmokeToolsHandle: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lObservabilitySmoke">>;
+export declare const hostAlarmSmokeToolsHandle: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lHostAlarmSmoke">>;
+export declare const gpsDevicesClusterPolicyDebugHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_CLUSTER_POLICY__">>;
+export declare const gpsDevicesViewportTraceHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE__">>;
+export declare const gpsDevicesViewportTraceEnabledHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE_ENABLED__">>;
+export declare const gpsDevicesDevicePanelHydrationDriverHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DEVICE_PANEL_HYDRATION_DRIVER__">>;
+export declare const gpsDevicesDocumentVisibilityDriverHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DOCUMENT_VISIBILITY_DRIVER__">>;
+export declare const gpsDevicesHiddenTabVisibilityShimHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_VISIBILITY_SHIM__">>;
+export declare const gpsDevicesHiddenTabDummyPlaybackShimHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_SHIM__">>;
+export declare const gpsDevicesNonSelectedViewportGateZoomSettleHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_NON_SELECTED_VIEWPORT_GATE_ZOOM_SETTLE__">>;
+export declare const gpsDevicesSparseRotationStationaryWaitHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_SPARSE_ROTATION_STATIONARY_WAIT__">>;
+export declare const gclickRealtimeDummyPlaybackDriverHandle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_DRIVER__">>;
+export declare const gclickGoogleMapsLoaderStateHandle: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lGoogleMapsLoaderState__">>;
+export declare const browserRuntimeHandles: Readonly<{
+    gclickGoogleMapsLoaderState: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lGoogleMapsLoaderState__">>;
+    gclickRealtimeDummyPlaybackDriver: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_DRIVER__">>;
+    gpsDevicesClusterPolicyDebug: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_CLUSTER_POLICY__">>;
+    gpsDevicesDevicePanelHydrationDriver: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DEVICE_PANEL_HYDRATION_DRIVER__">>;
+    gpsDevicesDocumentVisibilityDriver: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DOCUMENT_VISIBILITY_DRIVER__">>;
+    gpsDevicesHiddenTabDummyPlaybackShim: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_SHIM__">>;
+    gpsDevicesHiddenTabVisibilityShim: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_VISIBILITY_SHIM__">>;
+    gpsDevicesNonSelectedViewportGateZoomSettle: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_NON_SELECTED_VIEWPORT_GATE_ZOOM_SETTLE__">>;
+    gpsDevicesSparseRotationStationaryWait: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_SPARSE_ROTATION_STATIONARY_WAIT__">>;
+    gpsDevicesViewportTrace: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE__">>;
+    gpsDevicesViewportTraceEnabled: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE_ENABLED__">>;
+    hostAlarmSmokeTools: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lHostAlarmSmoke">>;
+    layoutsMfRuntimeErrors: Readonly<BrowserRuntimeSymbolHandleDefinition<"m4l.layouts.mfRuntimeErrors">>;
+    observabilitySmokeTools: Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lObservabilitySmoke">>;
+    realtimePerformanceDebug: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_PERFORMANCE__">>;
+    realtimeTransportDebug: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_TRANSPORT_DEBUG__">>;
+    realtimeRuntimeRegistry: Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_RUNTIMES__">>;
+}>;
+export declare const browserRuntimeHandleCatalogEntries: readonly [Readonly<BrowserRuntimeSymbolHandleDefinition<"m4l.layouts.mfRuntimeErrors">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_RUNTIMES__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_PERFORMANCE__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_REALTIME_TRANSPORT_DEBUG__">>, Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lObservabilitySmoke">>, Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lHostAlarmSmoke">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_CLUSTER_POLICY__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_GPS_DEVICES_VIEWPORT_TRACE_ENABLED__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DEVICE_PANEL_HYDRATION_DRIVER__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DOCUMENT_VISIBILITY_DRIVER__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_VISIBILITY_SHIM__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_SHIM__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_NON_SELECTED_VIEWPORT_GATE_ZOOM_SETTLE__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_SPARSE_ROTATION_STATIONARY_WAIT__">>, Readonly<BrowserRuntimeGlobalThisHandleDefinition<"__M4L_TEST_DUMMY_PLAYBACK_DRIVER__">>, Readonly<BrowserRuntimeWindowHandleDefinition<"__m4lGoogleMapsLoaderState__">>];
+export type BrowserRuntimeHandleId = typeof browserRuntimeHandleCatalogEntries[number]['id'];
+export type BrowserRuntimeHandleKey = typeof browserRuntimeHandleCatalogEntries[number]['key'];
+/**
+ * Canonical lookup by the stable catalog id used in docs and governance.
+ */
+export declare const browserRuntimeHandleCatalog: Readonly<Readonly<Record<string, BrowserRuntimeHandleDefinition>>>;
+/**
+ * Reverse lookup by the concrete browser runtime address used at execution time.
+ */
+export declare const browserRuntimeHandleCatalogByKey: Readonly<Readonly<Record<"globalThis.__M4L_REALTIME_RUNTIMES__" | "globalThis.__M4L_TEST_DUMMY_PLAYBACK_DRIVER__" | "Symbol.for('m4l.layouts.mfRuntimeErrors')" | "globalThis.__M4L_REALTIME_PERFORMANCE__" | "globalThis.__M4L_REALTIME_TRANSPORT_DEBUG__" | "window.__m4lObservabilitySmoke" | "window.__m4lHostAlarmSmoke" | "globalThis.__M4L_GPS_DEVICES_CLUSTER_POLICY__" | "globalThis.__M4L_GPS_DEVICES_VIEWPORT_TRACE__" | "globalThis.__M4L_GPS_DEVICES_VIEWPORT_TRACE_ENABLED__" | "globalThis.__M4L_TEST_DEVICE_PANEL_HYDRATION_DRIVER__" | "globalThis.__M4L_TEST_DOCUMENT_VISIBILITY_DRIVER__" | "globalThis.__M4L_TEST_VISIBILITY_SHIM__" | "globalThis.__M4L_TEST_DUMMY_PLAYBACK_SHIM__" | "globalThis.__M4L_NON_SELECTED_VIEWPORT_GATE_ZOOM_SETTLE__" | "globalThis.__M4L_SPARSE_ROTATION_STATIONARY_WAIT__" | "window.__m4lGoogleMapsLoaderState__", BrowserRuntimeHandleDefinition>>>;
+export {};

package/types/libs/observability/mf/src/diagnosticLogging.d.ts

@@ -0,0 +1,2 @@
+export type { DiagnosticAttributeValue, DiagnosticLogActivationMode, DiagnosticLogKind, DiagnosticLogLevel, DiagnosticLogRecord, DiagnosticPolicy, DiagnosticPolicyScope, DiagnosticPolicySource, DiagnosticPolicyTarget, DiagnosticPolicyTargetId, DiagnosticPolicyTransport, MFObservabilityService, ObservabilityService, } from '@m4l/observability/shared';
+export { noopMFObservabilityService, noopObservabilityService, } from '@m4l/observability/shared';

package/types/libs/observability/mf/src/diagnosticPolicies/catalog.d.ts

@@ -0,0 +1,267 @@
+import type { DiagnosticPolicyCatalogEntry } from './contracts';
+/**
+ * Flat diagnostic policy inventory used for audits, documentation, and future UI surfaces.
+ */
+export declare const diagnosticPolicyCatalogEntries: readonly ({
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/gclick_host/src/observability/dev/smoke.ts"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-06-05";
+    readonly id: "gclickHostDiagnosticSmoke";
+    readonly key: "gclick_host.observability.diagnostic-smoke";
+    readonly notes: readonly ["This family is primarily exercised through the browser smoke helper and support overrides."];
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Provide one deterministic browser-log smoke signal before support investigates a live issue.";
+    readonly summary: "Manual host smoke proof for browser diagnostic-log delivery.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "gclick_host.observability.diagnostic-smoke";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/gclick_host/src/observability/host/realtime.ts"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-06-05";
+    readonly id: "gclickHostRealtimeConnectionRecovery";
+    readonly key: "gclick_host.realtime.connection-recovery";
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Capture host websocket transport recovery evidence without waiting for a broader outage investigation.";
+    readonly summary: "Host realtime reconnect recovery breadcrumbs.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "gclick_host.realtime.connection-recovery";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["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"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-08-20";
+    readonly id: "gclickHostRealtimeTransportLifecycle";
+    readonly key: "gclick_host.realtime.transport-lifecycle";
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Capture host Atmosphere lifecycle breadcrumbs during temporary support investigations of reconnect storms and browser sleep recovery.";
+    readonly summary: "Host Atmosphere transport lifecycle breadcrumbs.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "gclick_host.realtime.transport-lifecycle";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/gclick_host/src/observability/diagnostic/diagnosticFeatureFlags.ts"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-06-08";
+    readonly id: "gclickHostRemoteDiagnosticProviderHealth";
+    readonly key: "gclick_host.feature-flags.remote-diagnostic-provider-health";
+    readonly notes: readonly ["This family is intentionally always-on because provider outages are recoverable anomalies, not optional debug breadcrumbs."];
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Report the first failure in a remote diagnostic-provider outage streak even when no support capture is active.";
+    readonly summary: "Host remote diagnostic-provider outage anomaly.";
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/gclick_host/src/observability/otlp/client.ts", "apps/gclick/gclick_host/src/observability/otlp/relayDiagnostics.ts", "libs/observability/web/src/browserOtlp.ts"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-06-16";
+    readonly id: "gclickHostTracesRelayDisabled";
+    readonly key: "gclick_host.observability.traces-relay-disabled";
+    readonly notes: readonly ["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."];
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Report the first permanent browser traces-relay shutdown together with the failure metadata that caused the relay to stop exporting.";
+    readonly summary: "Host browser traces-relay shutdown anomaly.";
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["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"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-06-14";
+    readonly id: "gclickHostRuntimeBoundaryCrash";
+    readonly key: "gclick_host.runtime-errors.boundary-crash";
+    readonly notes: readonly ["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."];
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Report contained host-shell and host-loaded MF boundary crashes as structured always-on diagnostic logs for dashboarding and alerting.";
+    readonly summary: "Host boundary crash anomaly for host shell and host-loaded MFs.";
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/gclick_host/src/observability/diagnostic/diagnosticFeatureFlags.ts"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-06-11";
+    readonly id: "gclickHostRefreshDebug";
+    readonly key: "gclick_host.feature-flags.refresh-debug";
+    readonly notes: readonly ["Use this family when support needs to understand why the browser refreshed, queued, or applied one remote diagnostic payload."];
+    readonly owner: {
+        readonly app: "gclick_host";
+        readonly runtime: "web";
+        readonly surface: "host";
+    };
+    readonly purpose: "Expose host-owned GrowthBook refresh breadcrumbs such as bootstrap, context, focus, visibility, poll, and queued refreshes.";
+    readonly summary: "Host remote diagnostic-provider refresh debug breadcrumbs.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "gclick_host.feature-flags.refresh-debug";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/subcomponents/ModuleMap/subcomponents/MapContent/subcomponents/DevicesPanel/subcomponents/DevicesPanelBody/subcomponents/DeviceCard/DeviceCard.tsx"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-06-05";
+    readonly id: "operativeMyGpsDevicesDeviceSelectionMissingPosition";
+    readonly key: "operative_my_gps_devices.device-selection.missing-position";
+    readonly owner: {
+        readonly app: "operative_my_gps_devices";
+        readonly moduleId: "operative_my_gps_devices";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Capture the user-visible branch where one selected device has no finite GNSS position and the map must skip focus safely.";
+    readonly summary: "MF selection branch for devices without finite GNSS position.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "operative_my_gps_devices.device-selection.missing-position";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["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"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-06-06";
+    readonly id: "operativeMyGpsDevicesMotionCapture";
+    readonly key: "operative_my_gps_devices.motion.capture";
+    readonly notes: readonly ["The closing session summary is treated as the final record of a policy-authorized capture session, not as a separate always-on anomaly lane."];
+    readonly owner: {
+        readonly app: "operative_my_gps_devices";
+        readonly moduleId: "operative_my_gps_devices";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Capture selected-device realtime ingress, motion-segment, and camera-follow evidence for support investigations.";
+    readonly summary: "MF targeted motion-capture diagnostic family.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "operative_my_gps_devices.motion.capture";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["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"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-08-20";
+    readonly id: "operativeMyGpsDevicesRealtimeTransportLifecycle";
+    readonly key: "operative_my_gps_devices.realtime.transport-lifecycle";
+    readonly owner: {
+        readonly app: "operative_my_gps_devices";
+        readonly moduleId: "operative_my_gps_devices";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Capture isolation Atmosphere lifecycle breadcrumbs during temporary support investigations of reconnect storms and browser sleep recovery.";
+    readonly summary: "My GPS Devices isolation Atmosphere transport lifecycle breadcrumbs.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "operative_my_gps_devices.realtime.transport-lifecycle";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/mfs/operative/operative_my_gps_devices/src/components/App/subcomponents/ModuleMap/subcomponents/MapContent/subcomponents/DeviceMarker/helpers/reportLeafletRuntimeError.ts"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-06-05";
+    readonly id: "operativeMyGpsDevicesRecoverableLeafletRuntime";
+    readonly key: "operative_my_gps_devices.recoverable.leaflet-runtime";
+    readonly owner: {
+        readonly app: "operative_my_gps_devices";
+        readonly moduleId: "operative_my_gps_devices";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Expose recovered Leaflet runtime anomalies that should never stay silent even without one active support capture.";
+    readonly summary: "MF always-on recovered Leaflet runtime anomaly.";
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/mfs/operative/operative_my_gps_devices/src/components/app_entries/ByIsolation/observability/diagnosticFeatureFlags.ts"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-06-08";
+    readonly id: "operativeMyGpsDevicesRemoteDiagnosticProviderHealth";
+    readonly key: "operative_my_gps_devices.feature-flags.remote-diagnostic-provider-health";
+    readonly owner: {
+        readonly app: "operative_my_gps_devices";
+        readonly moduleId: "operative_my_gps_devices";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Report isolation remote diagnostic-provider outages even when the active session has no support policy enabled.";
+    readonly summary: "MF isolation remote diagnostic-provider outage anomaly.";
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/mfs/shared/shared_reports_list/src/components/App/context/ReportContext"];
+    readonly controlPlane: "remote-policy";
+    readonly createdAt: "2026-08-22";
+    readonly id: "sharedReportsListReportsDebug";
+    readonly key: "shared_reports_list.feature-flags.reports-debug";
+    readonly notes: readonly ["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."];
+    readonly owner: {
+        readonly app: "shared_reports_list";
+        readonly moduleId: "shared_reports_list";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Allow support-enabled sessions to remove the reports/types test-worker exclusion filter.";
+    readonly summary: "Fallback product gate for the shared reports test report type.";
+    readonly remoteRule: {
+        readonly featureKey: "gclick-frontend-diagnostic-policies";
+        readonly payloadKey: "shared_reports_list.feature-flags.reports-debug";
+        readonly provider: "growthbook";
+        readonly supportedLayers: readonly ["moduleDefault", "accountOverride"];
+    };
+} | {
+    readonly active: true;
+    readonly codePaths: readonly ["apps/gclick/mfs/shared/shared_reports_list/src/components/appEntries/ByIsolation/observability/diagnosticFeatureFlags.ts"];
+    readonly controlPlane: "always-on";
+    readonly createdAt: "2026-08-24";
+    readonly id: "sharedReportsListRemoteDiagnosticProviderHealth";
+    readonly key: "shared_reports_list.feature-flags.remote-diagnostic-provider-health";
+    readonly owner: {
+        readonly app: "shared_reports_list";
+        readonly moduleId: "shared_reports_list";
+        readonly runtime: "web";
+        readonly surface: "mf";
+    };
+    readonly purpose: "Report isolation remote diagnostic-provider outages even when report debug is disabled.";
+    readonly summary: "MF isolation remote diagnostic-provider outage anomaly.";
+})[];
+/**
+ * Key-addressable view of the policy inventory for fast code-to-control-plane comparison.
+ */
+export declare const diagnosticPolicyCatalogByKey: Readonly<Record<string, DiagnosticPolicyCatalogEntry>>;

package/types/libs/observability/mf/src/diagnosticPolicies/contracts.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared GrowthBook feature key used by frontend-web diagnostic policy payloads.
+ */
+export declare const diagnosticPolicyWebFeatureKey = "gclick-frontend-diagnostic-policies";
+/**
+ * Shared remote payload layers currently supported by the frontend-web catalog.
+ */
+export declare const diagnosticPolicyWebLayers: readonly ["moduleDefault", "accountOverride"];
+export type DiagnosticPolicyCatalogDate = `${number}-${number}-${number}`;
+export type DiagnosticPolicyCatalogControlPlane = 'always-on' | 'remote-policy';
+export type DiagnosticPolicyCatalogRemoteLayer = (typeof diagnosticPolicyWebLayers)[number];
+export type DiagnosticPolicyCatalogRemoteProvider = 'growthbook';
+export type DiagnosticPolicyCatalogSurface = 'host' | 'mf';
+/**
+ * Owning runtime surface for one diagnostic policy family.
+ */
+export interface DiagnosticPolicyCatalogOwner {
+    app: string;
+    moduleId?: string;
+    runtime: 'web';
+    surface: DiagnosticPolicyCatalogSurface;
+}
+/**
+ * Remote-provider contract used to contrast code inventory with the active remote policy rule.
+ */
+export interface DiagnosticPolicyCatalogRemoteRule {
+    featureKey: string;
+    payloadKey: string;
+    provider: DiagnosticPolicyCatalogRemoteProvider;
+    supportedLayers: ReadonlyArray<DiagnosticPolicyCatalogRemoteLayer>;
+}
+/**
+ * Shared metadata required for every durable diagnostic policy inventory record.
+ */
+interface DiagnosticPolicyCatalogEntryBase<PolicyId extends string = string, PolicyKey extends string = string> {
+    active: boolean;
+    codePaths: ReadonlyArray<string>;
+    createdAt: DiagnosticPolicyCatalogDate;
+    id: PolicyId;
+    key: PolicyKey;
+    notes?: ReadonlyArray<string>;
+    owner: DiagnosticPolicyCatalogOwner;
+    purpose: string;
+    summary: string;
+}
+/**
+ * Durable inventory record for one always-on diagnostic policy family.
+ */
+interface DiagnosticPolicyCatalogAlwaysOnEntry<PolicyId extends string = string, PolicyKey extends string = string> extends DiagnosticPolicyCatalogEntryBase<PolicyId, PolicyKey> {
+    controlPlane: 'always-on';
+    remoteRule?: never;
+}
+/**
+ * Durable inventory record for one remotely configurable diagnostic policy family.
+ */
+interface DiagnosticPolicyCatalogRemotePolicyEntry<PolicyId extends string = string, PolicyKey extends string = string> extends DiagnosticPolicyCatalogEntryBase<PolicyId, PolicyKey> {
+    controlPlane: 'remote-policy';
+    remoteRule: DiagnosticPolicyCatalogRemoteRule;
+}
+/**
+ * Durable inventory record for one diagnostic policy family.
+ */
+export type DiagnosticPolicyCatalogEntry<PolicyId extends string = string, PolicyKey extends string = string> = DiagnosticPolicyCatalogAlwaysOnEntry<PolicyId, PolicyKey> | DiagnosticPolicyCatalogRemotePolicyEntry<PolicyId, PolicyKey>;
+export {};