@@ -0,0 +1,5 @@
+---
+'@object-ui/components': patch
+---
+
+A `kind:'react'` page keeps its own state when its host re-renders (objectui#13268). The page was recompiled whenever it received a new schema object, and the console hands it a fresh copy of the page on every render, so a re-render remounted the page: a selected record reset and an open drawer closed. The page now recompiles only when its content changes (its `source`, its `data` / `variables`, or any other page value it can read) or the adapter does. A changed source or value still recompiles and resets the page, as before.
@@ -0,0 +1,121 @@
+/**
+ * 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.
+ *
+ * A `kind:'react'` page recompiles on CONTENT, not on schema identity
+ * (objectui#13268).
+ *
+ * The console's `PageView` hands `SchemaRenderer` a fresh spread of the page
+ * schema on every render, and any other host may do the same. `ReactKindPage`
+ * used to key its scope on that object's identity, so every host re-render
+ * recompiled the page — a new `Page` function, a new element type, a remount —
+ * and the page's own `useState` was lost (measured on the showcase Task Desk:
+ * its `editId` reset and an open record drawer vanished).
+ *
+ * `react-page-state.test.tsx` did not catch it: its host re-renders with a
+ * module-scope schema, the one shape a real host does not produce. These pins
+ * re-render with a NEW object of EQUAL content, under StrictMode, and keep the
+ * controls that stop "stable" from meaning "stale": a changed source or a
+ * changed declared scope value still recompiles.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { SchemaRenderer, AdapterCtx } from '@object-ui/react';
+// Registers PageRenderer for `type:'home'`, which dispatches kind:'react'. At
+// module scope, not in a hook (object-ui/no-dynamic-import-in-test-hook).
+import '../renderers';
+
+const adapter = { find: async () => [], getObjectSchema: async () => ({ name: 'x', fields: {} }) } as any;
+
+/** A page with local state, which also prints a declared scope value. */
+const counterSource = (extra = '') => `
+function Page() {
+  const [n, setN] = React.useState(0);
+  return (
+    <div>
+      <button data-testid="counter" onClick={() => setN(n + 1)}>{n}</button>
+      <span data-testid="greeting">{variables.greeting}</span>
+      ${extra}
+    </div>
+  );
+}`;
+
+/** A FRESH schema object on every call, the shape `PageView` hands over. */
+function pageSchema(over: Record<string, unknown> = {}) {
+  return {
+    type: 'home',
+    kind: 'react',
+    name: 'identity_page',
+    source: counterSource(),
+    variables: { greeting: 'hello' },
+    context: { params: { appName: 'showcase' } },
+    ...over,
+  };
+}
+
+function Host({ tick, schema }: { tick: number; schema: any }) {
+  return (
+    <React.StrictMode>
+      <AdapterCtx.Provider value={adapter}>
+        <span data-testid="tick">{tick}</span>
+        <SchemaRenderer schema={schema} />
+      </AdapterCtx.Provider>
+    </React.StrictMode>
+  );
+}
+
+async function mountAndClick() {
+  const utils = render(<Host tick={0} schema={pageSchema()} />);
+  fireEvent.click(await utils.findByTestId('counter'));
+  expect(utils.getByTestId('counter').textContent).toBe('1');
+  return utils;
+}
+
+describe("kind:'react' page recompiles on content, not schema identity (objectui#13268)", () => {
+  it('keeps its state across a host re-render that hands it a new but equal schema object', async () => {
+    const { getByTestId, rerender } = await mountAndClick();
+
+    rerender(<Host tick={1} schema={pageSchema()} />);
+    rerender(<Host tick={2} schema={pageSchema()} />);
+
+    expect(getByTestId('tick').textContent).toBe('2');
+    // '0' means the page was remounted: a new schema object with the same
+    // content recompiled it.
+    expect(getByTestId('counter').textContent).toBe('1');
+  });
+
+  it('CONTROL: a changed source recompiles, and the page resets', async () => {
+    const { findByTestId, getByTestId, rerender } = await mountAndClick();
+
+    rerender(<Host tick={1} schema={pageSchema({ source: counterSource('<i data-testid="marker" />') })} />);
+
+    expect(await findByTestId('marker')).toBeTruthy();
+    expect(getByTestId('counter').textContent).toBe('0');
+  });
+
+  it('CONTROL: a changed declared scope value recompiles, reaches the page, and the page resets', async () => {
+    const { findByText, getByTestId, rerender } = await mountAndClick();
+    expect(getByTestId('greeting').textContent).toBe('hello');
+
+    rerender(<Host tick={1} schema={pageSchema({ variables: { greeting: 'bonjour' } })} />);
+
+    expect(await findByText('bonjour')).toBeTruthy();
+    // Scope values are compiled in, not passed as props: the new value reaches
+    // the page through a recompile, so the page's state resets with it.
+    expect(getByTestId('counter').textContent).toBe('0');
+  });
+
+  it('CONTROL: a changed nested page value (a route param) recompiles too', async () => {
+    const { getByTestId, rerender } = await mountAndClick();
+
+    rerender(<Host tick={1} schema={pageSchema({ context: { params: { appName: 'crm' } } })} />);
+
+    // `page` is a declared scope value, and `context.params` rides it.
+    expect(getByTestId('counter').textContent).toBe('0');
+  });
+});
@@ -11,7 +11,9 @@
  * compile — a new element TYPE, which React remounts. So the page's `useState`
  * survives only as long as nothing recompiles it, and that holds only while
  * BOTH links in the chain stay identity-stable: `ReactRunner` memoises on
- * `(code, scope)`, and `ReactKindPage` memoises `scope` on `[schema, adapter]`.
+ * `(code, scope)`, and `ReactKindPage` rebuilds `scope` only when the schema's
+ * CONTENT or the adapter changes (objectui#13268; a new but equal schema object
+ * is pinned in `react-page-content-identity.test.tsx`).
  *
  * Break either link and nothing fails loudly. Types check, every scope-contract
  * test still passes, the page still renders — it just silently drops whatever
 
@@ -148,6 +148,57 @@ function buildComponentScope(): Record<string, React.ComponentType<any>> {
  * an adapter.
  */
 
+/**
+ * The scope a react page's `source` is compiled against. Everything in it is
+ * either module-level (the block wrappers resolve through the registry when
+ * they render, the hooks are module functions) or read off `schema`, so equal
+ * schema content yields an equivalent scope.
+ */
+function buildPageScope(schema: { data?: unknown; variables?: unknown } | null | undefined): Record<string, unknown> {
+  return {
+    ...buildComponentScope(),
+    // Live data access — `const adapter = useAdapter()` inside the page, then
+    // adapter.find('object', {...}) / .create / .update. Hooks injected as
+    // closure vars; the page calls them from its own component body.
+    useAdapter,
+    // The data-invalidation bus reader (objectui#10887), the same hook
+    // `ListView` reads to refresh its rows. `useDataInvalidation('object')`
+    // returns a nonce that moves when the bus reports a write to that object
+    // (or `'*'`); a page names it in the dependency list of the effect that
+    // reads through `useAdapter`, and the read re-runs in place, with no
+    // remount. A module-level function, so it leaves the scope's identity
+    // exactly as stable as before.
+    useDataInvalidation,
+    data: schema?.data ?? schema?.variables ?? {},
+    variables: schema?.variables ?? {},
+    page: schema ?? {},
+  };
+}
+
+/**
+ * Structural equality for page metadata: plain objects and arrays compare by
+ * their own enumerable keys, everything else by `Object.is`. A value that is
+ * not plain data (a function, a `Date`, a class instance) is equal only to
+ * itself, so a host that hands over a new one recompiles the page, which is
+ * the conservative answer. `seen` keeps a cyclic value from recursing forever.
+ */
+function sameContent(a: unknown, b: unknown, seen: Map<object, object> = new Map()): boolean {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;
+  const proto = Object.getPrototypeOf(a);
+  if (proto !== Object.getPrototypeOf(b)) return false;
+  if (proto !== Object.prototype && proto !== Array.prototype && proto !== null) return false;
+  if (seen.get(a) === b) return true;
+  seen.set(a, b);
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!sameContent((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key], seen)) return false;
+  }
+  return true;
+}
+
 function CapabilityDisabledNotice(): React.ReactElement {
   return (
     <div className="m-4 rounded-md border border-amber-400/40 bg-amber-50 p-4 text-sm text-amber-900 dark:bg-amber-950/30 dark:text-amber-200">
@@ -195,36 +246,31 @@ export const ReactKindPage: React.FC<{ schema: any }> = ({ schema }) => {
   // scope there would reset every interactive page on the screen. It doesn't
   // need to — `buildComponentScope` already sees lazy blocks (objectui#2953).
   //
-  // `adapter` stays in the dependency list although the scope no longer
-  // carries it (objectui#11070). The blocks follow a swapped adapter through the
+  // The scope is rebuilt only when what it is compiled FROM changes: the
+  // schema's CONTENT (`page` carries all of it, `data` / `variables` are read
+  // off it) or the adapter. Not the schema object's identity — the console's
+  // `PageView` hands a fresh spread of the page on every render, and any host
+  // may, so keying on identity remounted the page on every host re-render
+  // (objectui#13268). The scope is held in state, not in a `useMemo`: React
+  // may discard a memo and hand back a new object, and here a new object IS a
+  // remount (AGENTS.md #10). When the content does change, the new scope is
+  // stored during render, React's pattern for state derived from props.
+  //
+  // `adapter` stays a rebuild trigger although the scope no longer carries it
+  // (objectui#11070). The blocks follow a swapped adapter through the
   // provider below without a recompile. The page's OWN code may not: an effect
   // that reads through `useAdapter()` and omits `adapter` from its dependencies
   // ran once, against the absent adapter, and the recompile on a swap (the
-  // host connecting one) is what re-runs it. Dropping the dependency would keep
+  // host connecting one) is what re-runs it. Dropping the trigger would keep
   // the page's state across a swap, but it would also leave such a page empty.
   // That is a separate behaviour change, not made here.
-  const scope = React.useMemo(
-    () => ({
-      ...buildComponentScope(),
-      // Live data access — `const adapter = useAdapter()` inside the page, then
-      // adapter.find('object', {...}) / .create / .update. Hooks injected as
-      // closure vars; the page calls them from its own component body.
-      useAdapter,
-      // The data-invalidation bus reader (objectui#10887), the same hook
-      // `ListView` reads to refresh its rows. `useDataInvalidation('object')`
-      // returns a nonce that moves when the bus reports a write to that object
-      // (or `'*'`); a page names it in the dependency list of the effect that
-      // reads through `useAdapter`, and the read re-runs in place, with no
-      // remount. A module-level function, so it leaves the scope's identity
-      // exactly as stable as before.
-      useDataInvalidation,
-      data: schema?.data ?? schema?.variables ?? {},
-      variables: schema?.variables ?? {},
-      page: schema ?? {},
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- `adapter` is a recompile trigger kept on purpose, not a read; the reason is above this memo.
-    [schema, adapter],
-  );
+  const [compiled, setCompiled] = React.useState(() => ({ schema, adapter, scope: buildPageScope(schema) }));
+  let scope = compiled.scope;
+  if (compiled.adapter !== adapter || !sameContent(compiled.schema, schema)) {
+    const next = { schema, adapter, scope: buildPageScope(schema) };
+    setCompiled(next);
+    scope = next.scope;
+  }
 
   // Capability gate — returned after all hooks above so hook order stays stable.
   if (!capabilityEnabled) {
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@object-ui/components': patch
 +---
++
 +A `kind:'react'` page keeps its own state when its host re-renders (objectui#13268). The page was recompiled whenever it received a new schema object, and the console hands it a fresh copy of the page on every render, so a re-render remounted the page: a selected record reset and an open drawer closed. The page now recompiles only when its content changes (its `source`, its `data` / `variables`, or any other page value it can read) or the adapter does. A changed source or value still recompiles and resets the page, as before.