diff --git a/client/src/components/Echart/somaticField3D/SomaticFieldDemo.tsx b/client/src/components/Echart/somaticField3D/SomaticFieldDemo.tsx
new file mode 100644
index 00000000..fe4b5575
--- /dev/null
+++ b/client/src/components/Echart/somaticField3D/SomaticFieldDemo.tsx
@@ -0,0 +1,189 @@
+import { useEffect, useRef } from "react";
+import { init, ECharts } from "echarts";
+import "echarts-gl";
+import { useSystem } from "context/system";
+import { buildBodyPointCloud } from "./bodyModel";
+import { RegionName, somaticCoord } from "./somaticMap";
+
+/**
+ * Self-contained, zero-data showcase of the Somatic Field for public surfaces
+ * (splash page). Synthetic experiences arise and pass through the body on a
+ * seamless loop while the camera slowly orbits. No auth, no GraphQL, no
+ * controls — drop it anywhere:
+ *
+ *   <SomaticFieldDemo height="480px" />
+ */
+
+type DemoEvent = {
+  t0: number;
+  dur: number;
+  coord: [number, number, number];
+  rgb: string;
+};
+
+const LOOP_S = 36;
+const RAMP_S = 0.5;
+const FADE_S = 3.2;
+
+const POSITIVE = "52,211,153";
+const NEGATIVE = "248,113,113";
+const NEUTRAL = "148,163,184";
+
+// A hand-shaped phenomenological loop: breath at the nostrils, a thought
+// stream in the head, feeling tones moving through chest and belly.
+const SCRIPT: {
+  region: RegionName;
+  rgb: string;
+  period: number;
+  dur: number;
+  phase: number;
+}[] = [
+  { region: "Nostrils", rgb: NEUTRAL, period: 4.5, dur: 2.2, phase: 0 },
+  { region: "Head", rgb: NEUTRAL, period: 6, dur: 1.6, phase: 1.2 },
+  { region: "Head", rgb: NEGATIVE, period: 13, dur: 2.2, phase: 7 },
+  { region: "Heart", rgb: POSITIVE, period: 9, dur: 2.8, phase: 3.5 },
+  { region: "Chest", rgb: NEGATIVE, period: 17, dur: 2.4, phase: 10 },
+  { region: "Solar Plexus", rgb: NEGATIVE, period: 15, dur: 2, phase: 5.5 },
+  { region: "Stomach", rgb: NEUTRAL, period: 11, dur: 1.8, phase: 8.2 },
+  { region: "Throat", rgb: NEUTRAL, period: 19, dur: 1.5, phase: 13 },
+  { region: "Hands", rgb: POSITIVE, period: 14, dur: 2, phase: 6.4 },
+  { region: "Legs", rgb: NEUTRAL, period: 21, dur: 1.7, phase: 15.5 },
+  { region: "Whole Body", rgb: POSITIVE, period: 18, dur: 3.5, phase: 11.3 },
+];
+
+const buildDemoEvents = (): DemoEvent[] => {
+  const events: DemoEvent[] = [];
+  let seed = 1;
+  for (const item of SCRIPT) {
+    for (let t = item.phase; t < LOOP_S; t += item.period) {
+      events.push({
+        t0: t,
+        dur: item.dur,
+        coord: somaticCoord(item.region, seed++),
+        rgb: item.rgb,
+      });
+    }
+  }
+  return events.sort((a, b) => a.t0 - b.t0);
+};
+
+const easeOutCubic = (k: number) => 1 - Math.pow(1 - k, 3);
+
+const AXIS_OFF = {
+  axisLine: { show: false },
+  axisTick: { show: false },
+  axisLabel: { show: false },
+  splitLine: { show: false },
+};
+
+type SomaticFieldDemoProps = {
+  height?: string;
+  className?: string;
+};
+
+const SomaticFieldDemo = ({
+  height = "480px",
+  className = "",
+}: SomaticFieldDemoProps) => {
+  const { darkMode } = useSystem();
+  const containerRef = useRef<HTMLDivElement>(null);
+  const chartRef = useRef<ECharts | null>(null);
+
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const chart = init(el, darkMode ? "dark" : "light", { renderer: "canvas" });
+    chartRef.current = chart;
+    chart.setOption({
+      backgroundColor: "transparent",
+      animation: false,
+      xAxis3D: { type: "value", min: -32, max: 32, ...AXIS_OFF },
+      yAxis3D: { type: "value", min: -32, max: 32, ...AXIS_OFF },
+      zAxis3D: { type: "value", min: -2, max: 104, ...AXIS_OFF },
+      grid3D: {
+        show: false,
+        boxWidth: 64,
+        boxDepth: 64,
+        boxHeight: 106,
+        viewControl: {
+          distance: 200,
+          alpha: 5,
+          beta: 0,
+          autoRotate: true,
+          autoRotateSpeed: 6,
+          zoomSensitivity: 0,
+          panSensitivity: 0,
+        },
+        light: {
+          main: { intensity: 1.1, shadow: false },
+          ambient: { intensity: 0.55 },
+        },
+      },
+      series: [
+        {
+          id: "body",
+          type: "scatter3D",
+          silent: true,
+          data: buildBodyPointCloud().map((p) => ({ value: p })),
+          symbolSize: 1.7,
+          itemStyle: {
+            color: darkMode ? "rgba(148,163,184,0.30)" : "rgba(100,116,139,0.26)",
+          },
+        },
+        { id: "events", type: "scatter3D", silent: true, data: [] },
+      ],
+    });
+
+    const events = buildDemoEvents();
+    const start = performance.now();
+    let raf = requestAnimationFrame(function step(now: number) {
+      const t = ((now - start) / 1000) % LOOP_S;
+      const data: {
+        value: [number, number, number];
+        symbolSize: number;
+        itemStyle: { color: string };
+      }[] = [];
+      for (const e of events) {
+        // Wrap-around so events straddling the loop boundary fade smoothly.
+        let age = t - e.t0;
+        if (age < 0) age += LOOP_S;
+        if (age > e.dur + FADE_S) continue;
+        const baseSize = 8 + 3 * e.dur;
+        let scale: number;
+        let alpha: number;
+        if (age < RAMP_S) {
+          const k = easeOutCubic(age / RAMP_S);
+          scale = k;
+          alpha = 0.9 * k;
+        } else if (age <= e.dur) {
+          scale = 1;
+          alpha = 0.9;
+        } else {
+          const k = (age - e.dur) / FADE_S;
+          scale = 1 - 0.7 * k;
+          alpha = 0.9 * (1 - k);
+        }
+        data.push({
+          value: e.coord,
+          symbolSize: baseSize * scale,
+          itemStyle: { color: `rgba(${e.rgb},${alpha.toFixed(3)})` },
+        });
+      }
+      chart.setOption({ series: [{ id: "events", data }] });
+      raf = requestAnimationFrame(step);
+    });
+
+    const resizeObserver = new ResizeObserver(() => chart.resize());
+    resizeObserver.observe(el);
+    return () => {
+      cancelAnimationFrame(raf);
+      resizeObserver.disconnect();
+      chart.dispose();
+      chartRef.current = null;
+    };
+  }, [darkMode]);
+
+  return <div ref={containerRef} className={`w-full ${className}`} style={{ height }} />;
+};
+
+export default SomaticFieldDemo;
diff --git a/client/src/components/Echart/somaticField3D/bodyModel.ts b/client/src/components/Echart/somaticField3D/bodyModel.ts
new file mode 100644
index 00000000..2484ce0e
--- /dev/null
+++ b/client/src/components/Echart/somaticField3D/bodyModel.ts
@@ -0,0 +1,109 @@
+/**
+ * Parametric 3D point-cloud human figure for the Somatic Field visualization.
+ *
+ * Same coordinate system as somaticMap.ts: z = height (0 feet → 100 crown),
+ * x = lateral, y = depth (positive = front). The figure is built from spheres
+ * and tapered capsules, sampled with a seeded PRNG so the cloud is identical
+ * on every render (stable point identity keeps the GL scene calm).
+ */
+
+type Point = [number, number, number];
+
+// mulberry32 — tiny deterministic PRNG.
+const makeRng = (seed: number) => {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+};
+
+/** Points on a sphere surface, optionally squashed per axis. */
+const sphere = (
+  rng: () => number,
+  center: Point,
+  r: number,
+  n: number,
+  scale: Point = [1, 1, 1]
+): Point[] => {
+  const pts: Point[] = [];
+  for (let i = 0; i < n; i++) {
+    const theta = rng() * Math.PI * 2;
+    const phi = Math.acos(rng() * 2 - 1);
+    pts.push([
+      center[0] + r * scale[0] * Math.sin(phi) * Math.cos(theta),
+      center[1] + r * scale[1] * Math.sin(phi) * Math.sin(theta),
+      center[2] + r * scale[2] * Math.cos(phi),
+    ]);
+  }
+  return pts;
+};
+
+/**
+ * Points on the lateral surface of a tapered capsule from p1 (radius r1) to
+ * p2 (radius r2). yScale flattens the cross-section front-to-back so the
+ * torso reads as a body rather than a tube.
+ */
+const capsule = (
+  rng: () => number,
+  p1: Point,
+  p2: Point,
+  r1: number,
+  r2: number,
+  n: number,
+  yScale = 1
+): Point[] => {
+  const pts: Point[] = [];
+  for (let i = 0; i < n; i++) {
+    const t = rng();
+    const r = r1 + (r2 - r1) * t;
+    const theta = rng() * Math.PI * 2;
+    pts.push([
+      p1[0] + (p2[0] - p1[0]) * t + r * Math.cos(theta),
+      p1[1] + (p2[1] - p1[1]) * t + r * yScale * Math.sin(theta),
+      p1[2] + (p2[2] - p1[2]) * t,
+    ]);
+  }
+  return pts;
+};
+
+const mirrorX = (pts: Point[]): Point[] => pts.map(([x, y, z]) => [-x, y, z]);
+
+let cache: Point[] | null = null;
+
+/** The standing figure, ~2,600 surface points. Memoized — pure geometry. */
+export const buildBodyPointCloud = (): Point[] => {
+  if (cache) return cache;
+  const rng = makeRng(42);
+  const pts: Point[] = [];
+
+  // Head + neck
+  pts.push(...sphere(rng, [0, 0.5, 90], 6.2, 320, [1, 1.1, 1.15]));
+  pts.push(...capsule(rng, [0, 0, 86], [0, 0, 81.5], 2.6, 3.2, 70));
+
+  // Torso (shoulders → waist) and pelvis, flattened front-to-back
+  pts.push(...capsule(rng, [0, 0, 79.5], [0, 0, 51], 10.5, 8.2, 700, 0.55));
+  pts.push(...capsule(rng, [0, 0, 51], [0, 0, 44.5], 8.4, 7.2, 160, 0.62));
+
+  // Right arm (upper, forearm, hand) then mirrored left
+  const rightArm: Point[] = [
+    ...capsule(rng, [11.5, 0, 78.5], [14, 1, 62], 2.9, 2.4, 150),
+    ...capsule(rng, [14, 1, 62], [16.5, 3, 45], 2.3, 1.9, 130),
+    ...sphere(rng, [17, 4, 42], 2, 45, [1, 1.4, 1.6]),
+  ];
+  pts.push(...rightArm, ...mirrorX(rightArm));
+
+  // Right leg (thigh, shin, foot) then mirrored left
+  const rightLeg: Point[] = [
+    ...capsule(rng, [4.8, 0, 46], [6, 1, 26], 4.2, 3, 200),
+    ...capsule(rng, [6, 1, 26], [6.5, 2, 5], 3, 2.2, 170),
+    ...capsule(rng, [6.5, 2, 1.8], [7, 8, 1.8], 2, 1.5, 55),
+  ];
+  pts.push(...rightLeg, ...mirrorX(rightLeg));
+
+  cache = pts;
+  return pts;
+};
diff --git a/client/src/components/Echart/somaticField3D/index.tsx b/client/src/components/Echart/somaticField3D/index.tsx
new file mode 100644
index 00000000..1b10aad1
--- /dev/null
+++ b/client/src/components/Echart/somaticField3D/index.tsx
@@ -0,0 +1,370 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { init, ECharts } from "echarts";
+import "echarts-gl";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import PauseIcon from "@mui/icons-material/Pause";
+import ReplayIcon from "@mui/icons-material/Replay";
+import { ManifestationOutput, SessionOutput, ValenceValueEnum } from "gql/graphql";
+import { RoundButton, Select, Text } from "components/ui";
+import type { SelectOption } from "components/ui";
+import { useSystem } from "context/system";
+import { buildBodyPointCloud } from "./bodyModel";
+import {
+  RegionName,
+  SomaticResolution,
+  resolveSomaticLocation,
+  somaticCoord,
+} from "./somaticMap";
+
+/**
+ * Somatic Field — a 3D body through which the session's experiences arise and
+ * pass in time. Each manifestation ignites at its somatic location (resolved
+ * from structured Body Location reports, free-text parsing, or its experience
+ * type's default region), holds for its input duration, then dissolves,
+ * leaving a faint residue. Colour = valence; size = input duration.
+ */
+
+type SomaticEvent = {
+  /** Seconds from session start when the experience begins. */
+  t0: number;
+  /** Input duration in seconds (clamped). */
+  dur: number;
+  coord: [number, number, number];
+  rgb: string;
+  label: string;
+  region: RegionName;
+  type: string;
+  source: SomaticResolution["source"];
+};
+
+const VALENCE_RGB: Record<string, string> = {
+  [ValenceValueEnum.Positive]: "52,211,153",
+  [ValenceValueEnum.Negative]: "248,113,113",
+  [ValenceValueEnum.Neutral]: "148,163,184",
+};
+const DEFAULT_RGB = "129,140,248";
+
+const RAMP_S = 0.35;
+const FADE_S = 2.5;
+const MIN_DUR_S = 1.2;
+const MAX_DUR_S = 60;
+
+const SPEED_OPTIONS: SelectOption[] = [1, 2, 4, 8, 16, 32].map((s) => ({
+  value: String(s),
+  label: `${s}×`,
+}));
+
+const easeOutCubic = (k: number) => 1 - Math.pow(1 - k, 3);
+
+const formatClock = (seconds: number) => {
+  const s = Math.max(0, Math.floor(seconds));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+};
+
+type Timeline = { events: SomaticEvent[]; total: number };
+
+const buildTimeline = (
+  manifestations: ManifestationOutput[],
+  session: SessionOutput
+): Timeline => {
+  const startMs = session.startTime ? Date.parse(session.startTime) : NaN;
+  const events: SomaticEvent[] = [];
+
+  manifestations.forEach((m, i) => {
+    const resolution = resolveSomaticLocation(m.type, m.value);
+    if (!resolution) return;
+
+    const beginMs = m.beginInputTimestamp ? Date.parse(m.beginInputTimestamp) : NaN;
+    const endMs = m.endInputTimestamp ? Date.parse(m.endInputTimestamp) : NaN;
+    if (!Number.isFinite(beginMs) || !Number.isFinite(startMs)) return;
+
+    const t0 = Math.max(0, (beginMs - startMs) / 1000);
+    const rawDur = Number.isFinite(endMs) ? (endMs - beginMs) / 1000 : 0;
+    const dur = Math.min(MAX_DUR_S, Math.max(MIN_DUR_S, rawDur));
+
+    events.push({
+      t0,
+      dur,
+      coord: somaticCoord(resolution.region, i + 1),
+      rgb: (m.valence && VALENCE_RGB[m.valence]) || DEFAULT_RGB,
+      label: (m.value || m.type || "").slice(0, 80),
+      region: resolution.region,
+      type: m.type || "",
+      source: resolution.source,
+    });
+  });
+
+  events.sort((a, b) => a.t0 - b.t0);
+  const sessionEndMs = session.endTime ? Date.parse(session.endTime) : NaN;
+  const sessionSpan = Number.isFinite(sessionEndMs) ? (sessionEndMs - startMs) / 1000 : 0;
+  const lastEvent = events.reduce((acc, e) => Math.max(acc, e.t0 + e.dur), 0);
+  const total = Math.max(sessionSpan, lastEvent + FADE_S, 1);
+  return { events, total };
+};
+
+type GlDataItem = {
+  value: [number, number, number];
+  name: string;
+  symbolSize: number;
+  itemStyle: { color: string };
+  region?: string;
+  expType?: string;
+};
+
+const eventDataAt = (events: SomaticEvent[], t: number) => {
+  const active: GlDataItem[] = [];
+  const residue: GlDataItem[] = [];
+  for (const e of events) {
+    if (e.t0 > t) break; // sorted by t0
+    const age = t - e.t0;
+    const baseSize = 7 + Math.min(10, 6 * Math.log10(1 + e.dur));
+    if (age <= e.dur + FADE_S) {
+      let scale: number;
+      let alpha: number;
+      if (age < RAMP_S) {
+        const k = easeOutCubic(age / RAMP_S);
+        scale = k;
+        alpha = 0.95 * k;
+      } else if (age <= e.dur) {
+        scale = 1;
+        alpha = 0.95;
+      } else {
+        const k = (age - e.dur) / FADE_S;
+        scale = 1 - 0.7 * k;
+        alpha = 0.95 * (1 - k);
+      }
+      active.push({
+        value: e.coord,
+        name: e.label,
+        symbolSize: baseSize * scale,
+        itemStyle: { color: `rgba(${e.rgb},${alpha.toFixed(3)})` },
+        region: e.region,
+        expType: e.type,
+      });
+    } else {
+      residue.push({
+        value: e.coord,
+        name: e.label,
+        symbolSize: 2.6,
+        itemStyle: { color: `rgba(${e.rgb},0.16)` },
+        region: e.region,
+        expType: e.type,
+      });
+    }
+  }
+  return { active, residue };
+};
+
+const AXIS_OFF = {
+  axisLine: { show: false },
+  axisTick: { show: false },
+  axisLabel: { show: false },
+  splitLine: { show: false },
+};
+
+const buildBaseOption = (darkMode: boolean) => ({
+  backgroundColor: "transparent",
+  animation: false,
+  tooltip: {
+    formatter: (params: { data?: GlDataItem }) => {
+      const d = params.data;
+      if (!d) return "";
+      return `${d.name}<br/><i>${d.region} · ${d.expType}</i>`;
+    },
+  },
+  xAxis3D: { type: "value", min: -32, max: 32, ...AXIS_OFF },
+  yAxis3D: { type: "value", min: -32, max: 32, ...AXIS_OFF },
+  zAxis3D: { type: "value", min: -2, max: 104, ...AXIS_OFF },
+  grid3D: {
+    show: false,
+    boxWidth: 64,
+    boxDepth: 64,
+    boxHeight: 106,
+    viewControl: {
+      distance: 210,
+      alpha: 5,
+      beta: 20,
+      center: [0, 0, 0],
+      autoRotate: false,
+      damping: 0.85,
+    },
+    light: {
+      main: { intensity: 1.1, shadow: false },
+      ambient: { intensity: 0.55 },
+    },
+  },
+  series: [
+    {
+      id: "body",
+      type: "scatter3D",
+      silent: true,
+      data: buildBodyPointCloud().map((p) => ({ value: p })),
+      symbolSize: 1.7,
+      itemStyle: {
+        color: darkMode ? "rgba(148,163,184,0.30)" : "rgba(100,116,139,0.26)",
+      },
+    },
+    { id: "residue", type: "scatter3D", silent: true, data: [], symbolSize: 2.6 },
+    {
+      id: "events",
+      type: "scatter3D",
+      data: [],
+      emphasis: { itemStyle: { opacity: 1 } },
+    },
+  ],
+});
+
+type SomaticField3DProps = {
+  manifestations: ManifestationOutput[];
+  session: SessionOutput;
+};
+
+const SomaticField3D = ({ manifestations, session }: SomaticField3DProps) => {
+  const { darkMode } = useSystem();
+  const containerRef = useRef<HTMLDivElement>(null);
+  const chartRef = useRef<ECharts | null>(null);
+  const clockRef = useRef({ t: 0, last: 0, lastDisplay: 0 });
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [speed, setSpeed] = useState(8);
+  const [displayT, setDisplayT] = useState(0);
+
+  const timeline = useMemo(
+    () => buildTimeline(manifestations || [], session),
+    [manifestations, session]
+  );
+
+  const renderFrame = (t: number) => {
+    const chart = chartRef.current;
+    if (!chart) return;
+    const { active, residue } = eventDataAt(timeline.events, t);
+    chart.setOption({
+      series: [
+        { id: "residue", data: residue },
+        { id: "events", data: active },
+      ],
+    });
+  };
+
+  // Chart lifecycle: re-created when theme or the underlying timeline changes.
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const chart = init(el, darkMode ? "dark" : "light", { renderer: "canvas" });
+    chartRef.current = chart;
+    chart.setOption(buildBaseOption(darkMode));
+    renderFrame(clockRef.current.t);
+    const resizeObserver = new ResizeObserver(() => chart.resize());
+    resizeObserver.observe(el);
+    return () => {
+      resizeObserver.disconnect();
+      chart.dispose();
+      chartRef.current = null;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [darkMode, timeline]);
+
+  // Playback clock.
+  useEffect(() => {
+    if (!isPlaying) return;
+    clockRef.current.last = performance.now();
+    let raf = requestAnimationFrame(function step(now: number) {
+      const clock = clockRef.current;
+      clock.t = Math.min(timeline.total, clock.t + ((now - clock.last) / 1000) * speed);
+      clock.last = now;
+      renderFrame(clock.t);
+      if (now - clock.lastDisplay > 200) {
+        clock.lastDisplay = now;
+        setDisplayT(clock.t);
+      }
+      if (clock.t >= timeline.total) {
+        setDisplayT(clock.t);
+        setIsPlaying(false);
+        return;
+      }
+      raf = requestAnimationFrame(step);
+    });
+    return () => cancelAnimationFrame(raf);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isPlaying, speed, timeline]);
+
+  const seek = (t: number) => {
+    clockRef.current.t = t;
+    setDisplayT(t);
+    renderFrame(t);
+  };
+
+  const togglePlay = () => {
+    if (!isPlaying && clockRef.current.t >= timeline.total) seek(0);
+    setIsPlaying(!isPlaying);
+  };
+
+  const atEnd = !isPlaying && displayT >= timeline.total;
+  const placed = timeline.events.length;
+  const totalCount = manifestations?.length || 0;
+
+  if (!placed) {
+    return (
+      <Text align="left" className="text-ds-fg3 text-sm">
+        None of this session's experiences resolve to a somatic location yet — add
+        mappings in somaticMap.ts to place them in the body.
+      </Text>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="flex flex-row flex-wrap items-center justify-between gap-2">
+        <Text align="left" className="text-ds-fg3 text-sm">
+          {placed} of {totalCount} experiences placed in the somatic field
+        </Text>
+        <div className="flex flex-row items-center gap-3 text-sm">
+          <span className="flex items-center gap-1 text-ds-fg3">
+            <span className="w-2.5 h-2.5 rounded-full bg-emerald-400 inline-block" />
+            positive
+          </span>
+          <span className="flex items-center gap-1 text-ds-fg3">
+            <span className="w-2.5 h-2.5 rounded-full bg-red-400 inline-block" />
+            negative
+          </span>
+          <span className="flex items-center gap-1 text-ds-fg3">
+            <span className="w-2.5 h-2.5 rounded-full bg-slate-400 inline-block" />
+            neutral
+          </span>
+        </div>
+      </div>
+
+      <div ref={containerRef} className="w-full h-[520px]" />
+
+      <div className="flex flex-row items-center gap-3">
+        <RoundButton size="sm" onClick={togglePlay}>
+          {isPlaying ? <PauseIcon /> : atEnd ? <ReplayIcon /> : <PlayArrowIcon />}
+        </RoundButton>
+        <input
+          type="range"
+          min={0}
+          max={1000}
+          value={timeline.total ? Math.round((displayT / timeline.total) * 1000) : 0}
+          onChange={(e) => {
+            setIsPlaying(false);
+            seek((parseInt(e.target.value, 10) / 1000) * timeline.total);
+          }}
+          className="flex-grow accent-ds-accent cursor-pointer"
+        />
+        <Text align="left" className="text-ds-fg3 text-sm tabular-nums whitespace-nowrap">
+          {formatClock(displayT)} / {formatClock(timeline.total)}
+        </Text>
+        <div className="w-24">
+          <Select
+            options={SPEED_OPTIONS}
+            value={SPEED_OPTIONS.find((o) => o.value === String(speed)) ?? null}
+            onChange={(o) =>
+              setSpeed(parseInt((o as SelectOption | null)?.value ?? "8", 10))
+            }
+          />
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default SomaticField3D;
diff --git a/client/src/components/Echart/somaticField3D/somaticMap.ts b/client/src/components/Echart/somaticField3D/somaticMap.ts
new file mode 100644
index 00000000..284f7b3e
--- /dev/null
+++ b/client/src/components/Echart/somaticField3D/somaticMap.ts
@@ -0,0 +1,374 @@
+/**
+ * Somatic mapping configuration for the 3D Somatic Field visualization.
+ *
+ * Coordinate system (matches bodyModel.ts): the body stands at the origin,
+ * z is height (0 = feet, 100 = crown), x is lateral (negative = body's right
+ * from the viewer's perspective), y is depth (positive = front of the body).
+ *
+ * THIS FILE IS THE EDITABLE SOMATIC ONTOLOGY. To change where an experience
+ * type lands in the body, edit EXPERIENCE_TYPE_SOMATIC below. Region anchors
+ * and text-parsing aliases live in BODY_REGIONS.
+ */
+
+export type RegionName =
+  | "Crown"
+  | "Head"
+  | "Forehead"
+  | "Eyes"
+  | "Ears"
+  | "Face"
+  | "Nose"
+  | "Nostrils"
+  | "Mouth"
+  | "Jaw"
+  | "Chin"
+  | "Neck"
+  | "Throat"
+  | "Shoulders"
+  | "Chest"
+  | "Heart"
+  | "Solar Plexus"
+  | "Stomach"
+  | "Abdomen"
+  | "Lower Belly"
+  | "Torso"
+  | "Spine"
+  | "Upper Back"
+  | "Back"
+  | "Lower Back"
+  | "Arms"
+  | "Hands"
+  | "Hips"
+  | "Legs"
+  | "Knees"
+  | "Feet"
+  | "Whole Body";
+
+export type BodyRegion = {
+  /** Anchor point [x, y, z] in body coordinates. */
+  coord: [number, number, number];
+  /**
+   * Per-axis jitter (standard deviation) so co-located events don't stack.
+   * Large spreads turn an anchor into a volume (e.g. Whole Body, Torso).
+   */
+  spread: [number, number, number];
+  /** Bilateral region: events alternate between +x and -x of the anchor. */
+  mirror?: boolean;
+  /** Lowercase substrings that resolve free text to this region. */
+  aliases: string[];
+};
+
+export const BODY_REGIONS: Record<RegionName, BodyRegion> = {
+  Crown: {
+    coord: [0, 0, 97],
+    spread: [2, 2, 1.5],
+    aliases: ["crown", "top of head", "top of the head"],
+  },
+  Head: {
+    coord: [0, 0, 90],
+    spread: [3, 2.5, 3],
+    aliases: ["head", "skull", "brain", "mind"],
+  },
+  Forehead: {
+    coord: [0, 4.5, 92],
+    spread: [2.5, 0.8, 1.2],
+    aliases: ["forehead", "forhead", "brow", "third eye"],
+  },
+  Eyes: {
+    coord: [0, 5, 90],
+    spread: [2.5, 0.8, 0.8],
+    aliases: ["eyes", "eye", "eyelid"],
+  },
+  Ears: {
+    coord: [6.5, 0, 90],
+    spread: [0.8, 1.2, 1.2],
+    mirror: true,
+    aliases: ["ears", "ear"],
+  },
+  Face: {
+    coord: [0, 5, 88.5],
+    spread: [2.5, 0.8, 2.5],
+    aliases: ["face", "cheek"],
+  },
+  Nose: { coord: [0, 6, 89], spread: [0.8, 0.8, 0.8], aliases: ["nose"] },
+  Nostrils: {
+    coord: [0, 6, 88.3],
+    spread: [0.9, 0.6, 0.5],
+    aliases: ["nostril", "nostrils"],
+  },
+  Mouth: {
+    coord: [0, 5.3, 87],
+    spread: [1.2, 0.6, 0.6],
+    aliases: ["mouth", "lips", "tongue"],
+  },
+  Jaw: { coord: [0, 4, 86.5], spread: [2.2, 0.8, 0.8], aliases: ["jaw"] },
+  Chin: { coord: [0, 5, 85.5], spread: [1, 0.6, 0.6], aliases: ["chin"] },
+  Neck: {
+    coord: [0, 0, 83],
+    spread: [1.8, 1.8, 1.5],
+    aliases: ["neck", "nape"],
+  },
+  Throat: {
+    coord: [0, 2.8, 82.5],
+    spread: [1.5, 0.8, 1.5],
+    aliases: ["throat"],
+  },
+  Shoulders: {
+    coord: [11, 0, 79],
+    spread: [1.8, 1.8, 1.2],
+    mirror: true,
+    aliases: ["shoulders", "shoulder"],
+  },
+  Chest: {
+    coord: [0, 4, 72],
+    spread: [4, 1.2, 3],
+    aliases: ["chest", "breast", "lungs", "lung"],
+  },
+  Heart: { coord: [-2.5, 4, 71], spread: [1.8, 1, 1.8], aliases: ["heart"] },
+  "Solar Plexus": {
+    coord: [0, 4.3, 63],
+    spread: [2, 1, 1.8],
+    aliases: ["solar plexus", "solarplexus", "diaphragm"],
+  },
+  Stomach: {
+    coord: [0, 4, 57],
+    spread: [2.5, 1.2, 2.2],
+    aliases: ["stomach", "belly", "gut", "tummy"],
+  },
+  Abdomen: {
+    coord: [0, 4, 53],
+    spread: [3, 1.2, 2.5],
+    aliases: ["abdomen", "abdominal", "navel"],
+  },
+  "Lower Belly": {
+    coord: [0, 4, 50],
+    spread: [2.5, 1.2, 1.8],
+    aliases: ["lower belly", "lower abdomen", "hara", "dantian"],
+  },
+  Torso: {
+    coord: [0, 0, 65],
+    spread: [6, 3.5, 12],
+    aliases: ["torso", "trunk", "core"],
+  },
+  Spine: {
+    coord: [0, -3.5, 66],
+    spread: [1, 1, 13],
+    aliases: ["spine", "spinal", "vertebra"],
+  },
+  "Upper Back": {
+    coord: [0, -4.5, 74],
+    spread: [4, 1, 3],
+    aliases: ["upper back"],
+  },
+  Back: { coord: [0, -4.5, 67], spread: [4.5, 1, 7], aliases: ["back"] },
+  "Lower Back": {
+    coord: [0, -4, 55],
+    spread: [3.5, 1, 2.5],
+    aliases: ["lower back", "lumbar"],
+  },
+  Arms: {
+    coord: [14.5, 1.5, 60],
+    spread: [1.8, 1.8, 9],
+    mirror: true,
+    aliases: ["arms", "arm", "elbow", "wrist", "forearm", "bicep"],
+  },
+  Hands: {
+    coord: [17, 4, 42],
+    spread: [1.5, 1.5, 1.8],
+    mirror: true,
+    aliases: ["hands", "hand", "palm", "fingers", "finger", "thumb"],
+  },
+  Hips: {
+    coord: [7.5, 0, 48],
+    spread: [1.8, 2, 1.8],
+    mirror: true,
+    aliases: ["hips", "hip", "pelvis", "groin"],
+  },
+  Legs: {
+    coord: [6, 1, 26],
+    spread: [2, 2, 14],
+    mirror: true,
+    aliases: ["legs", "leg", "thigh", "thighs", "calf", "calves", "shin"],
+  },
+  Knees: {
+    coord: [6, 3, 27],
+    spread: [1.2, 1.2, 1.5],
+    mirror: true,
+    aliases: ["knees", "knee"],
+  },
+  Feet: {
+    coord: [7, 4, 2],
+    spread: [1.5, 2.5, 1.2],
+    mirror: true,
+    aliases: ["feet", "foot", "toes", "toe", "heel", "sole"],
+  },
+  "Whole Body": {
+    coord: [0, 0, 55],
+    spread: [8, 4, 30],
+    aliases: ["whole body", "body", "everywhere", "all over", "skin"],
+  },
+};
+
+export type SomaticTypeRule = {
+  /** Default region for the experience type. null = no somatic placement. */
+  region: RegionName | null;
+  /**
+   * When true, the manifestation's free-text value is scanned for region
+   * aliases first ("pain in chest" → Chest); the region above is the fallback.
+   */
+  parseText?: boolean;
+};
+
+/**
+ * ExperienceType → somatic placement. Seeded with working defaults across the
+ * full ontology; refine per direction from the observer. Types absent from this
+ * map fall back to text parsing only.
+ */
+export const EXPERIENCE_TYPE_SOMATIC: Record<string, SomaticTypeRule> = {
+  // Cognitive / verbal stream — the thinking head.
+  "Verbal Thought": { region: "Head" },
+  "Binary Verbal Thought": { region: "Head" },
+  "Unsymbolized Thinking": { region: "Head" },
+  Belief: { region: "Head" },
+  Meaning: { region: "Head" },
+  Observation: { region: "Head" },
+  Perception: { region: "Head" },
+  "Perceived Mechanism": { region: "Head" },
+  "Factual Event": { region: "Head" },
+  "Factual Mechanism of Reaction": { region: "Head" },
+  Situation: { region: "Head" },
+  "Journal Entry": { region: "Head" },
+  "CBT Mental Distortions": { region: "Head" },
+  "CBT Reframing": { region: "Head" },
+
+  // Imagery — the visual field.
+  "Visual Thought": { region: "Eyes" },
+  "Mental Image": { region: "Eyes" },
+
+  // Meta-attention — crown.
+  "Attention Shift": { region: "Crown" },
+  "Concentration Lost": { region: "Crown" },
+  "Meditation Activity: Being Aware": { region: "Crown" },
+  "Meditation Activity: Focusing": { region: "Crown" },
+  "Meditation Activity: Imagining": { region: "Crown" },
+  "Meditation Activity: Observing": { region: "Crown" },
+  "Meditation Activity: Producing": { region: "Crown" },
+  "Meditation Activity: Releasing": { region: "Crown" },
+  "Meditation Activity: Moving": { region: "Whole Body" },
+  "Experience Dimension: Aperture": { region: "Crown" },
+  "Experience Dimension: Boredom": { region: "Crown" },
+  "Experience Dimension: Clarity": { region: "Crown" },
+  "Experience Dimension: Conflict": { region: "Crown" },
+  "Experience Dimension: Dereification": { region: "Crown" },
+  "Experience Dimension: Effort": { region: "Crown" },
+  "Experience Dimension: Emotion": { region: "Heart" },
+  "Experience Dimension: Meta-Awareness": { region: "Crown" },
+  "Experience Dimension: Object Orientation": { region: "Crown" },
+  "Experience Dimension: Source": { region: "Crown" },
+  "Experience Dimension: Stability": { region: "Crown" },
+  "Experience Dimension: Wakefulness": { region: "Crown" },
+
+  // Affective stream — heart and chest.
+  Emotion: { region: "Heart", parseText: true },
+  "Gratitude Thought": { region: "Heart" },
+  "The Four Immeasurable Minds": { region: "Heart" },
+  "Unmet Desire": { region: "Chest" },
+  Trigger: { region: "Solar Plexus" },
+
+  // Interoceptive events.
+  Breath: { region: "Nostrils" },
+  "Breath Noticed": { region: "Nostrils" },
+  "Heartbeat Noticed": { region: "Heart" },
+  "Hunger Noticed": { region: "Stomach" },
+  Contraction: { region: "Solar Plexus", parseText: true },
+
+  // Somatic free-text types — parse the report, fall back to the field.
+  "Body Sensation": { region: "Whole Body", parseText: true },
+  "Pain Noticed": { region: "Whole Body", parseText: true },
+  "Generic Valenced Sensation": { region: "Whole Body", parseText: true },
+  "Sensory Awareness": { region: "Whole Body", parseText: true },
+  "Earth Element Sensation": { region: "Whole Body", parseText: true },
+  "Fire Element Sensation": { region: "Whole Body", parseText: true },
+  "Water Element Sensation": { region: "Whole Body", parseText: true },
+  "Wind Element Sensation": { region: "Whole Body", parseText: true },
+  "Unified Mindfulness All Labels": { region: "Whole Body", parseText: true },
+
+  // Behaviour expresses through the hands more than anywhere else.
+  Behavior: { region: "Hands", parseText: true },
+
+  // Body Location values ARE regions; resolveSomaticLocation special-cases it.
+  "Body Location": { region: null, parseText: true },
+};
+
+export type SomaticResolution = {
+  region: RegionName;
+  /** How the placement was derived, in order of confidence. */
+  source: "structured" | "text" | "typeDefault";
+};
+
+// Longest aliases first so "solar plexus" wins over "back", "lower back" over "back".
+const ALIAS_INDEX: { alias: string; region: RegionName }[] = (
+  Object.entries(BODY_REGIONS) as [RegionName, BodyRegion][]
+)
+  .flatMap(([region, def]) => def.aliases.map((alias) => ({ alias, region })))
+  .sort((a, b) => b.alias.length - a.alias.length);
+
+const matchRegionInText = (text: string): RegionName | null => {
+  const lower = text.toLowerCase();
+  for (const { alias, region } of ALIAS_INDEX) {
+    const idx = lower.indexOf(alias);
+    if (idx === -1) continue;
+    // Word-boundary check so "ear" doesn't match "heard".
+    const before = idx === 0 ? " " : lower[idx - 1];
+    const after =
+      idx + alias.length >= lower.length ? " " : lower[idx + alias.length];
+    if (/[a-z]/.test(before) || /[a-z]/.test(after)) continue;
+    return region;
+  }
+  return null;
+};
+
+/**
+ * Resolve a manifestation to a body region.
+ * 1. "Body Location" manifestations: the value names the region (structured).
+ * 2. Types flagged parseText: scan the value for region aliases.
+ * 3. Fall back to the type's default region.
+ */
+export const resolveSomaticLocation = (
+  type: string | null | undefined,
+  value: string | null | undefined
+): SomaticResolution | null => {
+  const rule = type ? EXPERIENCE_TYPE_SOMATIC[type] : undefined;
+
+  if (type === "Body Location" && value) {
+    const region = matchRegionInText(value);
+    if (region) return { region, source: "structured" };
+  }
+
+  if (rule?.parseText && value) {
+    const region = matchRegionInText(value);
+    if (region) return { region, source: "text" };
+  }
+
+  if (rule?.region) return { region: rule.region, source: "typeDefault" };
+  return null;
+};
+
+/** Deterministic jittered coordinate for an event within its region. */
+export const somaticCoord = (
+  region: RegionName,
+  jitterSeed: number
+): [number, number, number] => {
+  const def = BODY_REGIONS[region];
+  // Three cheap deterministic pseudo-random values in [-1, 1].
+  const rand = (n: number) => {
+    const x = Math.sin(jitterSeed * 127.1 + n * 311.7) * 43758.5453;
+    return (x - Math.floor(x)) * 2 - 1;
+  };
+  const [sx, sy, sz] = def.spread;
+  let x = def.coord[0] + rand(1) * sx;
+  const y = def.coord[1] + rand(2) * sy;
+  const z = def.coord[2] + rand(3) * sz;
+  if (def.mirror && rand(4) < 0) x = -x;
+  return [x, y, z];
+};
diff --git a/client/src/components/visualizations/registry.ts b/client/src/components/visualizations/registry.ts
index bc138085..53cc442f 100644
--- a/client/src/components/visualizations/registry.ts
+++ b/client/src/components/visualizations/registry.ts
@@ -87,6 +87,14 @@ export const VISUALIZATION_META: Record<VisualizationEnum, VizMeta> = {
     appliesTo: [MeasurementKind.Session],
     requires: () => true,
   },
+  [VisualizationEnum.SomaticField]: {
+    id: VisualizationEnum.SomaticField,
+    appliesTo: [MeasurementKind.Session],
+    // Placement comes from the manifestation-level somatic map, which covers
+    // most experience types. TET values are retrospective intensity ratings
+    // whose input timestamps are a submit burst, so live placement is wrong.
+    requires: (tv) => !isTET(tv),
+  },
 };
 
 /**
@@ -102,6 +110,7 @@ export const DEFAULT_REVIEW_ORDER: VisualizationEnum[] = [
   VisualizationEnum.ValenceRadar,
   VisualizationEnum.WordCloud,
   VisualizationEnum.ExperienceTimeline,
+  VisualizationEnum.SomaticField,
   VisualizationEnum.ExperiencesTable,
 ];
 
@@ -124,7 +133,9 @@ export const resolveReviewVisualizations = (
 ): VisualizationEnum[] => {
   const stored = tv?.reviewVisualizations;
   const base =
-    stored && stored.length > 0 ? (stored as VisualizationEnum[]) : defaultReviewSet(tv);
+    stored && stored.length > 0
+      ? (stored as VisualizationEnum[])
+      : defaultReviewSet(tv);
   return base.filter((id) => VISUALIZATION_META[id]?.requires(tv));
 };
 
diff --git a/client/src/gql/graphql.ts b/client/src/gql/graphql.ts
index d88eb736..5ae7d981 100644
--- a/client/src/gql/graphql.ts
+++ b/client/src/gql/graphql.ts
@@ -226820,6 +226820,7 @@ export enum VisualizationEnum {
   BreathCounting = 'BreathCounting',
   ExperienceTimeline = 'ExperienceTimeline',
   ExperiencesTable = 'ExperiencesTable',
+  SomaticField = 'SomaticField',
   TemporalExperienceTrace = 'TemporalExperienceTrace',
   ValenceRadar = 'ValenceRadar',
   WordCloud = 'WordCloud'
diff --git a/client/src/pages/sessions/components/SessionReview/visualizationRenderers.tsx b/client/src/pages/sessions/components/SessionReview/visualizationRenderers.tsx
index 091ecd4e..320675de 100644
--- a/client/src/pages/sessions/components/SessionReview/visualizationRenderers.tsx
+++ b/client/src/pages/sessions/components/SessionReview/visualizationRenderers.tsx
@@ -14,6 +14,7 @@ import ExperiencesTable from "./components/ExperiencesTable";
 import SessionsWordCloud from "components/visualizations/SessionsWordCloud";
 import SessionBreathCounting from "components/Echart/sessionBreathCounting";
 import TemporalExperienceTrace from "components/Echart/temporalExperienceTrace";
+import SomaticField3D from "components/Echart/somaticField3D";
 
 const SectionTitle = ({ children }: { children: React.ReactNode }) => (
   <h3 className="text-lg font-semibold text-ds-fg">{children}</h3>
@@ -143,9 +144,7 @@ export const VISUALIZATION_RENDERERS: Record<
       <ExperienceTimeline
         data={timelineData}
         duration={ctx.session?.duration || 0}
-        startTime={
-          ctx.session?.startTime ? new Date(ctx.session.startTime).getTime() : 0
-        }
+        startTime={ctx.session?.startTime ? new Date(ctx.session.startTime).getTime() : 0}
         reportingMode={ctx.tv?.reportingMode}
       />
     );
@@ -158,4 +157,13 @@ export const VISUALIZATION_RENDERERS: Record<
       updateValence={ctx.updateValence}
     />
   ),
+
+  [VisualizationEnum.SomaticField]: (ctx) => (
+    <>
+      <SectionTitle>Somatic Field</SectionTitle>
+      <div className="bg-ds-paper border border-ds-line rounded-lg p-4">
+        <SomaticField3D manifestations={ctx.manifestations || []} session={ctx.session} />
+      </div>
+    </>
+  ),
 };
diff --git a/client/src/utils/enumMaps/VisualizationEnum.ts b/client/src/utils/enumMaps/VisualizationEnum.ts
index 740a4723..5526ddd5 100644
--- a/client/src/utils/enumMaps/VisualizationEnum.ts
+++ b/client/src/utils/enumMaps/VisualizationEnum.ts
@@ -38,21 +38,31 @@ export const VisualizationMap = createEnumMap(VisualizationEnum, {
   [VisualizationEnum.WordCloud]: {
     label: "Word Cloud",
     shortLabel: "Words",
-    description: "Word-frequency cloud over reported text, filterable by experience type.",
+    description:
+      "Word-frequency cloud over reported text, filterable by experience type.",
     sortOrder: 5,
   },
   [VisualizationEnum.ExperienceTimeline]: {
     label: "Experience Timeline",
     shortLabel: "Timeline",
-    description: "Manifestations laid out over session time, colored by valence.",
+    description:
+      "Manifestations laid out over session time, colored by valence.",
     sortOrder: 6,
   },
   [VisualizationEnum.ExperiencesTable]: {
     label: "Experiences Table",
     shortLabel: "Table",
-    description: "Sortable, filterable table of every manifestation in the session.",
+    description:
+      "Sortable, filterable table of every manifestation in the session.",
     sortOrder: 7,
   },
+  [VisualizationEnum.SomaticField]: {
+    label: "Somatic Field",
+    shortLabel: "Somatic",
+    description:
+      "3D body playback: experiences arise and pass at their somatic location over session time.",
+    sortOrder: 8,
+  },
 });
 
 export const visualizationDropdownOptions = VisualizationMap.dropdownOptions;
diff --git a/server/src/generated/resolvers.json b/server/src/generated/resolvers.json
index 6e626194..cabbede9 100644
--- a/server/src/generated/resolvers.json
+++ b/server/src/generated/resolvers.json
@@ -203,7 +203,8 @@
     "ValenceRadar": "ValenceRadar",
     "WordCloud": "WordCloud",
     "BreathCounting": "BreathCounting",
-    "TemporalExperienceTrace": "TemporalExperienceTrace"
+    "TemporalExperienceTrace": "TemporalExperienceTrace",
+    "SomaticField": "SomaticField"
   },
   "JSON": "JSON",
   "SequenceTypeOutput": {},
diff --git a/server/src/generated/stringDef.graphql b/server/src/generated/stringDef.graphql
index 0ef55e9a..db8e6d55 100644
--- a/server/src/generated/stringDef.graphql
+++ b/server/src/generated/stringDef.graphql
@@ -13653,6 +13653,7 @@ enum VisualizationEnum {
   BreathCounting
   ExperienceTimeline
   ExperiencesTable
+  SomaticField
   TemporalExperienceTrace
   ValenceRadar
   WordCloud
diff --git a/server/src/generated/typeDefs.json b/server/src/generated/typeDefs.json
index 16cb7019..b421c020 100644
--- a/server/src/generated/typeDefs.json
+++ b/server/src/generated/typeDefs.json
@@ -206084,6 +206084,14 @@
           },
           "directives": []
         },
+        {
+          "kind": "EnumValueDefinition",
+          "name": {
+            "kind": "Name",
+            "value": "SomaticField"
+          },
+          "directives": []
+        },
         {
           "kind": "EnumValueDefinition",
           "name": {
@@ -206395,6 +206403,6 @@
   ],
   "loc": {
     "start": 0,
-    "end": 361184
+    "end": 361199
   }
 }
\ No newline at end of file
diff --git a/server/src/resources/ogm-types.ts b/server/src/resources/ogm-types.ts
index fc594b85..bff8d093 100644
--- a/server/src/resources/ogm-types.ts
+++ b/server/src/resources/ogm-types.ts
@@ -20056,6 +20056,7 @@ export enum ScoreValueTypeEnum {
 /** Top-level grouping for cross-modality search results in the Command+K palette. Each scope fans out to one or more Neo4j @fulltext indexes with shared access-control semantics. */
 export enum SearchScopeEnum {
   Concepts = "CONCEPTS",
+  Events = "EVENTS",
   Grants = "GRANTS",
   Lab = "LAB",
   Library = "LIBRARY",
@@ -20305,6 +20306,7 @@ export enum VisualizationEnum {
   BreathCounting = "BreathCounting",
   ExperienceTimeline = "ExperienceTimeline",
   ExperiencesTable = "ExperiencesTable",
+  SomaticField = "SomaticField",
   TemporalExperienceTrace = "TemporalExperienceTrace",
   ValenceRadar = "ValenceRadar",
   WordCloud = "WordCloud",
diff --git a/server/src/resources/utils/enums/visualization.ts b/server/src/resources/utils/enums/visualization.ts
index e4f4f8ee..99ef8884 100644
--- a/server/src/resources/utils/enums/visualization.ts
+++ b/server/src/resources/utils/enums/visualization.ts
@@ -16,6 +16,7 @@ export enum VisualizationEnum {
   WordCloud = "WordCloud",
   BreathCounting = "BreathCounting",
   TemporalExperienceTrace = "TemporalExperienceTrace",
+  SomaticField = "SomaticField",
 }
 
 registerEnumType(VisualizationEnum, {