diff --git a/.changeset/6270-schemarenderer-scopeclass-memo.md b/.changeset/6270-schemarenderer-scopeclass-memo.md
new file mode 100644
index 000000000..39f1e262c
--- /dev/null
+++ b/.changeset/6270-schemarenderer-scopeclass-memo.md
@@ -0,0 +1,26 @@
+---
+'@object-ui/react': patch
+---
+
+`SchemaRenderer` now hands a stable `schema` object identity to a node carrying
+`responsiveStyles` (objectui#6270).
+
+ADR-0065 scoped styles make a styled node take a branch that rebuilds the schema
+object to merge the generated scope class into `className`. That rebuild was not
+memoised, so it allocated a new object on **every** `SchemaRenderer` render — even
+when the `evaluatedSchema` memo directly above it held. Every downstream renderer
+that memoises on `[schema]` therefore saw a fresh identity and re-ran: concretely
+`ObjectMap`'s `dataConfig` and `mapConfig`, and the whole marker cascade below them
+(`markers` → `filteredMarkers` → `clusteredData` / `markerBounds` → `initialViewState`).
+Only nodes on that branch were affected — a plain node was already handed the
+memoised `evaluatedSchema` itself.
+
+The trigger is narrower than "has `responsiveStyles`" reads: it needs one of the four
+sized breakpoint keys (`large` / `medium` / `small` / `xsmall`). A `{ base: … }` shape
+never took the branch and was never affected.
+
+The scoped-style computation now lives in a `useMemo` keyed on
+`[evaluatedSchema, autoStyleId]`, hoisted above the renderer's early returns — its old
+use site sits after them, so a memo written there would have been a conditional hook.
+A genuinely changed `className`, interpolated value or breakpoint still produces a new
+identity, so nothing goes stale.
diff --git a/packages/react/src/SchemaRenderer.tsx b/packages/react/src/SchemaRenderer.tsx
index 1fe6b2a88..e92c91f09 100644
--- a/packages/react/src/SchemaRenderer.tsx
+++ b/packages/react/src/SchemaRenderer.tsx
@@ -1098,6 +1098,71 @@ export const SchemaRenderer: ForwardRefExoticComponent<
     return newSchema;
   }, [schema, dataSource, predicateScope, pageVariables, boundRecord]);
 
+  /**
+   * SDUI scoped styling (ADR-0065): a node's `responsiveStyles` compiles to
+   * id-scoped CSS injected as a `<style>` tag, and a scope class is appended to
+   * the node's className.
+   *
+   * ## Why this is a memo, and why it is HERE and not at its use site
+   *
+   * The scope-class branch rebuilds the schema object (`{ ...evaluatedSchema,
+   * className: mergedClassName }`) so renderers that read `schema.className`
+   * see the scope class. Unmemoised, that spread allocated a NEW object on
+   * every render of this component — even when the `evaluatedSchema` memo
+   * directly above it HELD — so every downstream renderer that memoises on
+   * `[schema]` (e.g. `ObjectMap`'s `dataConfig` / `mapConfig`, and the whole
+   * marker cascade below them) saw a fresh identity and re-ran (objectui#6270).
+   * Only nodes taking this branch were affected: a plain node was handed
+   * `evaluatedSchema` itself and was already stable.
+   *
+   * It is hoisted ABOVE the early returns below because it is a HOOK. Its use
+   * site sits after `if (!evaluatedSchema) return null`, the `_hidden` return
+   * and the unresolved-component returns, so a `useMemo` written there is a
+   * CONDITIONAL hook: a node toggling hidden -> visible would call one more
+   * hook than the previous render and React would throw "Rendered more hooks
+   * than during the previous render". Hoisting is what makes the memo legal,
+   * not a stylistic preference.
+   *
+   * `[evaluatedSchema, autoStyleId]` is the complete dependency set: every
+   * value below is a pure function of the evaluated node (`className`, `id`,
+   * `responsiveStyles`) and the `useId` fallback. `evaluatedSchema` is itself a
+   * fresh object whenever anything it interpolates changes, so a genuinely
+   * changed className, value or breakpoint still produces a NEW identity here —
+   * memoising cannot make a live value go stale.
+   *
+   * Non-object / primitive nodes fall through untouched: the render pass below
+   * returns them as text before any of this is read.
+   */
+  const scopedStyling = useMemo(() => {
+    const node = evaluatedSchema;
+    if (!node || typeof node !== 'object') {
+      return { scopeClass: '', scopedCss: '', mergedClassName: undefined, schemaForComponent: node };
+    }
+    const responsiveStyles = (node as Record<string, unknown>).responsiveStyles;
+    if (!hasResponsiveStyles(responsiveStyles)) {
+      // No scope class: hand the component `evaluatedSchema` ITSELF, which the
+      // memo above already keeps stable. Never a copy — a copy here would
+      // reintroduce the same instability for every node in the tree.
+      return {
+        scopeClass: '',
+        scopedCss: '',
+        mergedClassName: node.className,
+        schemaForComponent: node,
+      };
+    }
+    const scopeClass = scopeClassFor(node.id ?? autoStyleId);
+    const mergedClassName = [node.className, scopeClass].filter(Boolean).join(' ');
+    return {
+      scopeClass,
+      scopedCss: compileScopedStyles(`.${scopeClass}`, responsiveStyles),
+      mergedClassName,
+      // Some renderers read `schema.className` directly (e.g. element:text)
+      // while others read the `className` prop (e.g. flex/container). Set both
+      // so the scope class lands regardless of which channel a renderer honours.
+      schemaForComponent: { ...node, className: mergedClassName },
+    };
+  }, [evaluatedSchema, autoStyleId]);
+
   if (!evaluatedSchema) return null;
   // If schema is just a string, render it as text
   if (typeof evaluatedSchema === 'string') return <>{evaluatedSchema}</>;
@@ -1237,21 +1302,9 @@ export const SchemaRenderer: ForwardRefExoticComponent<
     );
   }
 
-  // SDUI scoped styling (ADR-0065): a node's `responsiveStyles` compiles to
-  // id-scoped CSS injected as a <style> tag, and a scope class is appended to
-  // the node's className. Build-independent, collision-free, responsive-correct.
-  const hasScopedStyles = hasResponsiveStyles(_responsiveStyles);
-  const scopeClass = hasScopedStyles ? scopeClassFor(evaluatedSchema.id ?? autoStyleId) : '';
-  const scopedCss = hasScopedStyles ? compileScopedStyles(`.${scopeClass}`, _responsiveStyles) : '';
-  const mergedClassName = scopeClass
-    ? [evaluatedSchema.className, scopeClass].filter(Boolean).join(' ')
-    : evaluatedSchema.className;
-  // Some renderers read `schema.className` directly (e.g. element:text) while
-  // others read the `className` prop (e.g. flex/container). Set both so the
-  // scope class lands regardless of which channel a renderer honours.
-  const schemaForComponent = scopeClass
-    ? { ...evaluatedSchema, className: mergedClassName }
-    : evaluatedSchema;
+  // SDUI scoped styling (ADR-0065) — computed in the memo hoisted above the
+  // early returns; see the doc comment there for why it cannot live here.
+  const { scopeClass, scopedCss, mergedClassName, schemaForComponent } = scopedStyling;
 
   // Extract AriaPropsSchema properties for accessibility
   const ariaProps = resolveAriaProps(evaluatedSchema);
diff --git a/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx b/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx
new file mode 100644
index 000000000..c0ac4563c
--- /dev/null
+++ b/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx
@@ -0,0 +1,389 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Identity stability of the `schema` object `SchemaRenderer` hands down
+ * (objectui#6270).
+ *
+ * `SchemaRenderer` memoises `evaluatedSchema`, and downstream renderers key
+ * their own `useMemo`s on `[schema]` (e.g. `ObjectMap`'s `dataConfig` /
+ * `mapConfig`). A node carrying `responsiveStyles` (ADR-0065 scoped styles)
+ * takes a spread branch that merges the scope class into `schema.className` —
+ * and that spread used to run unmemoised, allocating a NEW object on every
+ * `SchemaRenderer` render even when the `evaluatedSchema` memo above it held.
+ * Every downstream `[schema]` memo therefore saw a fresh identity and re-ran.
+ *
+ * ## The reproduction trap this file exists to pin
+ *
+ * `hasResponsiveStyles` requires a `large` / `medium` / `small` / `xsmall`
+ * key. A `{ base: … }` shape does NOT take the branch — a fixture built on
+ * `base` measures "stable" no matter what the renderer does, and reads as
+ * evidence that the report was wrong. So `takes the scope-class branch` below
+ * runs FIRST and proves, from the delivered `schema.className`, which fixture
+ * is on which side of the branch. Every stability assertion after it is only
+ * meaningful because that one passed.
+ *
+ * ## Both directions are pinned
+ *
+ * Memoising an object that legitimately changes trades a re-render bug for a
+ * stale-render bug, so the `delivers a NEW identity` block pins the opposite
+ * direction: when `className`, an evaluated value, or the source schema really
+ * changes, the identity handed down MUST change with it.
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import React, { useState } from 'react';
+import { ComponentRegistry } from '@object-ui/core';
+import { SchemaRenderer } from '../SchemaRenderer';
+import { PageVariablesProvider, usePageVariables } from '../hooks/usePageVariables';
+
+/** One capture per probe render: the exact `schema` object it was handed. */
+interface Capture {
+  schema: any;
+  classNameProp: unknown;
+}
+
+const captures = new Map<string, Capture[]>();
+
+/**
+ * The probe is registered in the real `ComponentRegistry` and reached through
+ * the real `SchemaRenderer` path — not a unit call to an internal helper. What
+ * it records is exactly what any downstream renderer would key a `[schema]`
+ * memo on.
+ */
+const IdentityProbe: React.FC<any> = (props) => {
+  const id = String(props.schema?.id ?? 'anon');
+  const list = captures.get(id) ?? [];
+  list.push({ schema: props.schema, classNameProp: props.className });
+  captures.set(id, list);
+  return <div data-testid={`probe-${id}`} />;
+};
+
+const capturesFor = (id: string): Capture[] => captures.get(id) ?? [];
+
+/** Number of times the probe for `id` rendered. Guards every "stable" claim:
+ *  an identity cannot be measured across a re-render that never happened. */
+const renderCount = (id: string): number => capturesFor(id).length;
+
+/** How many DISTINCT `schema` objects the probe for `id` was handed. */
+const distinctIdentities = (id: string): number =>
+  new Set(capturesFor(id).map((c) => c.schema)).size;
+
+// Module-level fixtures: a stable `schema` prop identity is the precondition
+// for the `evaluatedSchema` memo to hold, which is what makes this a test of
+// the spread branch rather than of the memo above it.
+const PLAIN = { type: 'identity-probe', id: 'plain', content: 'plain' };
+const SCOPED = {
+  type: 'identity-probe',
+  id: 'scoped',
+  content: 'scoped',
+  responsiveStyles: { large: { padding: '8px' } },
+};
+// The trap fixture: `base` is NOT one of the four sized keys, so this node
+// does not take the scope-class branch at all.
+const BASE_ONLY = {
+  type: 'identity-probe',
+  id: 'baseonly',
+  content: 'base-only',
+  responsiveStyles: { base: { padding: '8px' } },
+};
+
+/**
+ * A real parent re-render: parent state changes, every child re-renders, and
+ * every `schema` prop below keeps its identity.
+ *
+ * The re-render is driven by a real click rather than by a module-level `let`
+ * the component reassigns during render. That reassignment is itself a render
+ * side effect (`react-hooks/globals`) — in a file that measures render counts,
+ * it would be the measuring instrument breaking the rule under test.
+ */
+const Harness: React.FC = () => {
+  const [, setTick] = useState(0);
+  return (
+    <>
+      <button data-testid="bump-parent" onClick={() => setTick((n) => n + 1)} />
+      <SchemaRenderer schema={PLAIN} />
+      <SchemaRenderer schema={SCOPED} />
+      <SchemaRenderer schema={BASE_ONLY} />
+    </>
+  );
+};
+
+/** One parent re-render. */
+const bumpParent = (): void => {
+  fireEvent.click(screen.getByTestId('bump-parent'));
+};
+
+describe('SchemaRenderer scoped-style schema identity (objectui#6270)', () => {
+  // Registered ONCE, outside the per-test hooks: `register`/`unregister` call
+  // the registry's `notify()`, which force-updates every mounted
+  // `SchemaRenderer`. Doing that per-test fires it while the previous test's
+  // tree is still mounted, producing un-acted updates — noise that would sit
+  // on top of the very re-render counts this file measures.
+  beforeAll(() => {
+    ComponentRegistry.register('identity-probe', IdentityProbe);
+  });
+
+  afterAll(() => {
+    ComponentRegistry.unregister?.('identity-probe');
+  });
+
+  beforeEach(() => {
+    captures.clear();
+  });
+
+  afterEach(() => {
+    captures.clear();
+  });
+
+  describe('the fixtures are on the sides of the branch this file claims', () => {
+    it('only a sized-breakpoint node takes the scope-class branch', () => {
+      render(<Harness />);
+
+      // Positive control for the two zero/absent readings below, same query
+      // shape: the sized-breakpoint node DOES get a scope class, on both the
+      // `schema.className` channel and the `className` prop channel.
+      expect(capturesFor('scoped')[0].schema.className).toContain('os-s-scoped');
+      expect(String(capturesFor('scoped')[0].classNameProp)).toContain('os-s-scoped');
+
+      // The trap: `{ base: … }` is not one of the four sized keys.
+      expect(capturesFor('baseonly')[0].schema.className).toBeUndefined();
+      expect(capturesFor('baseonly')[0].classNameProp).toBeUndefined();
+
+      expect(capturesFor('plain')[0].schema.className).toBeUndefined();
+      expect(capturesFor('plain')[0].classNameProp).toBeUndefined();
+    });
+  });
+
+  describe('identity is stable across a parent re-render', () => {
+    it('plain node (control)', () => {
+      render(<Harness />);
+      bumpParent();
+
+      expect(renderCount('plain')).toBeGreaterThanOrEqual(2);
+      expect(distinctIdentities('plain')).toBe(1);
+    });
+
+    it('node with a `base`-only responsiveStyles shape (control)', () => {
+      render(<Harness />);
+      bumpParent();
+
+      expect(renderCount('baseonly')).toBeGreaterThanOrEqual(2);
+      expect(distinctIdentities('baseonly')).toBe(1);
+    });
+
+    it('node with a sized responsiveStyles breakpoint (the fix case)', () => {
+      render(<Harness />);
+      bumpParent();
+
+      expect(renderCount('scoped')).toBeGreaterThanOrEqual(2);
+      expect(distinctIdentities('scoped')).toBe(1);
+    });
+
+    it('holds across several parent re-renders, not just one', () => {
+      render(<Harness />);
+      bumpParent();
+      bumpParent();
+      bumpParent();
+
+      expect(renderCount('scoped')).toBeGreaterThanOrEqual(4);
+      expect(distinctIdentities('scoped')).toBe(1);
+      expect(distinctIdentities('plain')).toBe(1);
+    });
+
+    it('the scope class survives memoisation — a stable identity is still the RIGHT object', () => {
+      render(<Harness />);
+      bumpParent();
+
+      const last = capturesFor('scoped')[renderCount('scoped') - 1];
+      expect(last.schema.className).toContain('os-s-scoped');
+      expect(last.schema.content).toBe('scoped');
+      expect(last.schema.type).toBe('identity-probe');
+      // `responsiveStyles` reaches the renderer on the schema object (it is
+      // stripped from the DOM props, not from the schema).
+      expect(last.schema.responsiveStyles).toEqual({ large: { padding: '8px' } });
+    });
+  });
+
+  describe("the instability is bounded — a consumer's own setState does not re-key it", () => {
+    /**
+     * Pins the reason this finding is a redundant-recompute cost and NOT a
+     * refetch loop. A consuming renderer (`ObjectMap`) keys a fetch effect on
+     * a `[schema]`-derived memo and that effect calls `setData`. If the
+     * renderer's OWN state update re-ran `SchemaRenderer`, a fresh schema
+     * identity would re-key the effect, refetch, and set state again —
+     * unbounded.
+     *
+     * It does not: React re-renders only the subtree below the component that
+     * set state, so `SchemaRenderer` stays put and the consumer keeps the very
+     * object React last handed it. This test fixes that as a property of the
+     * renderer rather than a fact people re-derive from React semantics. It is
+     * green on both sides of the fix — the fix changes what a PARENT render
+     * hands down, and this measures renders no parent took part in — and turns
+     * red only if something upstream starts re-rendering `SchemaRenderer` in
+     * response to a consumer's own state.
+     */
+    it('a consumer re-rendering itself keeps the exact schema object it was handed', () => {
+      const selfUpdates: any[] = [];
+
+      const SelfUpdatingProbe: React.FC<any> = (props) => {
+        const [, setOwn] = useState(0);
+        selfUpdates.push(props.schema);
+        return <button data-testid="bump-self" onClick={() => setOwn((n) => n + 1)} />;
+      };
+
+      ComponentRegistry.register('self-updating-probe', SelfUpdatingProbe);
+      try {
+        render(
+          <SchemaRenderer
+            schema={{
+              type: 'self-updating-probe',
+              id: 'selfscoped',
+              responsiveStyles: { large: { padding: '8px' } },
+            }}
+          />
+        );
+
+        // Measured from the LAST render before the first click, not from mount.
+        //
+        // Mount is not a clean baseline: `SchemaRenderer` force-updates itself
+        // once after mounting (it re-checks `ComponentRegistry` for a lazily
+        // registered component), so mounting alone produces two SchemaRenderer
+        // renders — and before the fix those two already handed down two
+        // different schema objects. Counting from mount would fold that
+        // parent-render instability into this test and make it a second, worse
+        // copy of the fix-case test above instead of the independent property
+        // it is meant to pin. (Measured: this assertion goes red on the pre-fix
+        // tree when it starts at index 0, and stays green when it starts here.)
+        const mountRenders = selfUpdates.length;
+        const baseline = selfUpdates[mountRenders - 1];
+
+        fireEvent.click(screen.getByTestId('bump-self'));
+        fireEvent.click(screen.getByTestId('bump-self'));
+
+        // Positive control: the consumer really did re-render on its own state.
+        expect(selfUpdates.length).toBeGreaterThan(mountRenders);
+        // The property: across the consumer's OWN re-renders, the schema object
+        // it holds never changes — SchemaRenderer did not re-run, so there was
+        // nothing to re-key. This is what makes the finding bounded.
+        expect(new Set(selfUpdates.slice(mountRenders - 1)).size).toBe(1);
+        // The branch is genuinely taken here too — otherwise this pins nothing.
+        expect(baseline.className).toContain('os-s-selfscoped');
+      } finally {
+        ComponentRegistry.unregister?.('self-updating-probe');
+      }
+    });
+  });
+
+  describe('delivers a NEW identity when something really changed (anti-staleness)', () => {
+    it('a changed `className` on a scoped node', () => {
+      const before = {
+        type: 'identity-probe',
+        id: 'scoped',
+        className: 'text-sm',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+      const after = {
+        type: 'identity-probe',
+        id: 'scoped',
+        className: 'text-lg',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+
+      const { rerender } = render(<SchemaRenderer schema={before} />);
+      expect(capturesFor('scoped')[0].schema.className).toBe('text-sm os-s-scoped');
+
+      rerender(<SchemaRenderer schema={after} />);
+
+      const last = capturesFor('scoped')[renderCount('scoped') - 1];
+      expect(last.schema.className).toBe('text-lg os-s-scoped');
+      expect(last.schema).not.toBe(capturesFor('scoped')[0].schema);
+    });
+
+    it('a changed value on a scoped node', () => {
+      const before = {
+        type: 'identity-probe',
+        id: 'scoped',
+        content: 'first',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+      const after = {
+        type: 'identity-probe',
+        id: 'scoped',
+        content: 'second',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+
+      const { rerender } = render(<SchemaRenderer schema={before} />);
+      rerender(<SchemaRenderer schema={after} />);
+
+      const first = capturesFor('scoped')[0];
+      const last = capturesFor('scoped')[renderCount('scoped') - 1];
+      expect(first.schema.content).toBe('first');
+      expect(last.schema.content).toBe('second');
+      expect(last.schema).not.toBe(first.schema);
+    });
+
+    it('a changed responsiveStyles value re-compiles and re-identifies', () => {
+      const before = {
+        type: 'identity-probe',
+        id: 'scoped',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+      const after = {
+        type: 'identity-probe',
+        id: 'scoped',
+        responsiveStyles: { large: { padding: '24px' } },
+      };
+
+      const { rerender } = render(<SchemaRenderer schema={before} />);
+      rerender(<SchemaRenderer schema={after} />);
+
+      const first = capturesFor('scoped')[0];
+      const last = capturesFor('scoped')[renderCount('scoped') - 1];
+      expect(last.schema).not.toBe(first.schema);
+      expect(last.schema.responsiveStyles).toEqual({ large: { padding: '24px' } });
+    });
+
+    it('a live value the node interpolates — same schema object, changed page variable', () => {
+      // The strongest anti-staleness pin: the `schema` PROP identity never
+      // changes here, so only a genuinely reactive evaluation can move the
+      // delivered identity. A memo that froze on the prop would go stale.
+      const REACTIVE = {
+        type: 'identity-probe',
+        id: 'reactive',
+        content: '${page.tick}',
+        responsiveStyles: { large: { padding: '8px' } },
+      };
+
+      const TickWriter: React.FC = () => {
+        const { setVariable } = usePageVariables();
+        return (
+          <button data-testid="set-tick" onClick={() => setVariable('tick', 'second')} />
+        );
+      };
+
+      render(
+        <PageVariablesProvider
+          definitions={[{ name: 'tick', type: 'string', defaultValue: 'first' } as any]}
+        >
+          <TickWriter />
+          <SchemaRenderer schema={REACTIVE} />
+        </PageVariablesProvider>
+      );
+
+      expect(capturesFor('reactive')[0].schema.content).toBe('first');
+
+      fireEvent.click(screen.getByTestId('set-tick'));
+
+      const first = capturesFor('reactive')[0];
+      const last = capturesFor('reactive')[renderCount('reactive') - 1];
+      expect(last.schema.content).toBe('second');
+      expect(last.schema).not.toBe(first.schema);
+    });
+  });
+});