@@ -0,0 +1,14 @@
+---
+'@object-ui/data-objectstack': patch
+'@object-ui/plugin-designer': patch
+'@object-ui/app-shell': patch
+---
+
+fix(plugin-designer): the fields page and the objects page save an object as its author wrote it, not as the console is served it
+
+Clause-②: yes
+Metadata-protocol: none
+
+`MetadataFieldsPage` took its edit base from the item read and `MetadataObjectsPage` from the list read. The server translates both for the console's `Accept-Language` and fills both with the platform's injected columns (`owner_id` and the rest), and both pages spread that served object back as the save body. In a Chinese console one field relabel or one description edit therefore stored every other label of the object in Chinese, and the injected columns as authored fields. Both pages now build the save body on the object as authored, `overlay ?? code` from the layered read (`GET /meta/object/:name/layers`, served untranslated). The fields page shows and edits the authored fields. The objects page keeps showing the listed object as served and writes back only the keys the edit changed. When the layered read holds neither layer, the fields page says the object was not found and the objects page saves nothing and says why.
+
+`@object-ui/data-objectstack` now exports the reading itself, `authoredBuffer`, `authoredPublished` and `editsAuthoredLayers` with the `AuthoredBuffer` and `AuthoredLayers` types, beside `MetadataClient.layered`. `@object-ui/app-shell` re-exports them from its `authoredObjectBuffer.ts` with no change in behaviour, so its editors and plugin-designer's pages share one copy.
@@ -1,112 +1,21 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 /**
- * objectstack#29793, objectstack#30786 — the ONE reading of which document a
- * metadata editor edits: the item as its author wrote it, never the item as it
- * is served.
- *
- * The served reads are for display. For every type whose served reads the
- * server translates (`TRANSLATABLE_METADATA_TYPES`, the predicate the REST
- * read itself asks), `GET /meta/:type/:name?state=draft` answers the pending
- * draft translated for the console's `Accept-Language`: a view's or a page's
- * `label`, an app's navigation labels, a dashboard's widget titles. An object's
- * draft read is governed besides, with the platform's injected columns (`owner_id`,
- * `queue`, the audit and scope columns) in `fields`, and so is the layered read's
- * `effective` for an object. An editor that seeded its buffer from the served
- * draft and saved it back stored the translations as the author's text, and an
- * object's injected columns as author fields.
- *
- * The author-owned document is the layered read's, spelled by the contract
- * (`GetMetaItemLayeredResponseSchema.draft`): the `draft` layer, the pending
- * draft row as stored, `null` when none is pending. A server serves it only to a
- * caller its draft-read admission admits, and that same admission gates the
- * `?state=draft` read, so a caller that was served a draft body was served the
- * layer too. When the two disagree (a draft body served, no `draft` key on the
- * layers) there is no author-owned copy of that draft to edit: the answer is
- * `unserved`, the editor installs no buffer, and nothing is sent over the draft.
- * ⛔ Never fall back to the served draft body there: that is the translated
- * document this module exists to keep out of the buffer.
- *
- * With no draft pending, the buffer is the published item as authored
- * ({@link authoredPublished}): an object's `overlay ?? code`, because its
- * `effective` is governed; every other type's `effective ?? code`, which the
- * layered read serves untranslated and which stays the server's own reading of
- * the published item (the layered read decides it, not this module).
- *
- * Display may stay translated: the projection reads (published field names,
- * diagnostics, the header) keep reading what is served. Only the buffer moves.
+ * objectstack#29793, objectstack#30786 — the editors' reading of which document
+ * they edit is `@object-ui/data-objectstack`'s `authoredBuffer` (its docblock is
+ * the authority), re-exported here with the object editor's spellings and the
+ * display-only {@link servedOnlyFields}.
  */
 
-import { TRANSLATABLE_METADATA_TYPES } from '@objectstack/spec/system';
+import { authoredBuffer, authoredPublished, type AuthoredBuffer, type AuthoredLayers } from '@object-ui/data-objectstack';
 import { readFields, type FieldEntry } from './previews/object-fields-io.js';
 
-/** The parts of the layered read this reading takes. */
-export interface AuthoredLayers {
-  code?: unknown;
-  overlay?: unknown;
-  effective?: unknown;
-  draft?: unknown;
-}
+export { authoredBuffer, authoredPublished, editsAuthoredLayers } from '@object-ui/data-objectstack';
+export type { AuthoredBuffer, AuthoredLayers } from '@object-ui/data-objectstack';
 
 /** The object editor's spelling of {@link AuthoredLayers}. */
 export type ObjectLayers = AuthoredLayers;
 
-export type AuthoredBuffer =
-  | {
-      kind: 'buffer';
-      /** The document the editor edits and saves. */
-      body: Record<string, unknown>;
-      /** True when `body` is the pending draft row. */
-      fromDraft: boolean;
-    }
-  | {
-      /** A draft is pending, and the layered read served no stored copy of it. */
-      kind: 'unserved';
-    };
-
-function asDocument(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-/**
- * Whether an editor of `type` takes its buffer from the layers: the served reads
- * of the type are translated, so its served draft is not the author's document.
- * Any other type's served draft is the stored row (`objectui#10765`), and its
- * editors keep reading it.
- */
-export function editsAuthoredLayers(type: string): boolean {
-  return TRANSLATABLE_METADATA_TYPES.has(type);
-}
-
-/**
- * The editor's buffer for `type` from the layered read, and the draft body the
- * `?state=draft` read served (`extractDraftBody`, `null` when none is pending).
- * The served body only says whether a draft is pending; its content is never
- * the buffer.
- */
-export function authoredBuffer(
-  type: string,
-  layers: AuthoredLayers | null | undefined,
-  servedDraft: Record<string, unknown> | null,
-): AuthoredBuffer {
-  const stored = layers && 'draft' in layers ? asDocument(layers.draft) : null;
-  if (stored) return { kind: 'buffer', body: stored, fromDraft: true };
-  if (servedDraft) return { kind: 'unserved' };
-  return { kind: 'buffer', body: authoredPublished(type, layers), fromDraft: false };
-}
-
-/**
- * The published item as its author wrote it: the buffer after a step that
- * leaves no draft to edit (a discard, a reset, a publish that promoted it).
- * An object's `overlay ?? code`; every other type's `effective ?? code`.
- */
-export function authoredPublished(type: string, layers: AuthoredLayers | null | undefined): Record<string, unknown> {
-  if (type === 'object') return asDocument(layers?.overlay) ?? asDocument(layers?.code) ?? {};
-  return asDocument(layers?.effective) ?? asDocument(layers?.code) ?? {};
-}
-
 /** {@link authoredBuffer} for an object. */
 export function authoredObjectBuffer(
   layers: ObjectLayers | null | undefined,
 
@@ -0,0 +1,72 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#30786 — pins the one reading of which document an editor edits
+ * (`authored-layers.ts`), now that it lives here for every editor that saves a
+ * metadata item. The editors' own suites pin what reaches the wire; this file
+ * pins the reading itself, case by case.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { TRANSLATABLE_METADATA_TYPES } from '@objectstack/spec/system';
+import { authoredBuffer, authoredPublished, editsAuthoredLayers } from './index';
+
+const CODE = { name: 'n', label: 'Code' };
+const OVERLAY = { name: 'n', label: 'Overlay' };
+const EFFECTIVE = { name: 'n', label: 'Effective' };
+const DRAFT = { name: 'n', label: 'Draft' };
+const SERVED_DRAFT = { name: 'n', label: '草稿' };
+
+describe('editsAuthoredLayers', () => {
+  it('answers by the spec set the server translates by, and by nothing else', () => {
+    for (const type of TRANSLATABLE_METADATA_TYPES) expect(editsAuthoredLayers(type)).toBe(true);
+    expect(editsAuthoredLayers('flow')).toBe(false);
+    expect(editsAuthoredLayers('datasource')).toBe(false);
+  });
+});
+
+describe('authoredPublished', () => {
+  it('an object is `overlay ?? code`, never its governed `effective`', () => {
+    expect(authoredPublished('object', { code: CODE, overlay: OVERLAY, effective: EFFECTIVE })).toBe(OVERLAY);
+    expect(authoredPublished('object', { code: CODE, overlay: null, effective: EFFECTIVE })).toBe(CODE);
+    expect(authoredPublished('object', { code: null, overlay: OVERLAY, effective: EFFECTIVE })).toBe(OVERLAY);
+  });
+
+  it('any other type is the layered read\'s own `effective ?? code`', () => {
+    expect(authoredPublished('view', { code: CODE, overlay: OVERLAY, effective: EFFECTIVE })).toBe(EFFECTIVE);
+    expect(authoredPublished('view', { code: CODE, overlay: null, effective: null })).toBe(CODE);
+  });
+
+  it('no layer at all, or a layer that is not a document, is `{}`', () => {
+    expect(authoredPublished('object', null)).toEqual({});
+    expect(authoredPublished('object', { code: 'text', overlay: ['x'] })).toEqual({});
+  });
+});
+
+describe('authoredBuffer', () => {
+  it('a pending draft is the stored `draft` layer, as stored', () => {
+    expect(authoredBuffer('view', { code: CODE, draft: DRAFT }, SERVED_DRAFT)).toEqual({
+      kind: 'buffer',
+      body: DRAFT,
+      fromDraft: true,
+    });
+  });
+
+  it('a served draft with no `draft` layer is `unserved`, never the served body', () => {
+    expect(authoredBuffer('view', { code: CODE }, SERVED_DRAFT)).toEqual({ kind: 'unserved' });
+    expect(authoredBuffer('object', { code: CODE, draft: null }, SERVED_DRAFT)).toEqual({ kind: 'unserved' });
+  });
+
+  it('no draft pending is the published item as authored', () => {
+    expect(authoredBuffer('object', { code: CODE, overlay: OVERLAY, effective: EFFECTIVE, draft: null }, null)).toEqual({
+      kind: 'buffer',
+      body: OVERLAY,
+      fromDraft: false,
+    });
+    expect(authoredBuffer('dashboard', { code: CODE, effective: EFFECTIVE }, null)).toEqual({
+      kind: 'buffer',
+      body: EFFECTIVE,
+      fromDraft: false,
+    });
+  });
+});
@@ -0,0 +1,108 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#29793, objectstack#30786 — the ONE reading of which document a
+ * metadata editor edits: the item as its author wrote it, never the item as it
+ * is served.
+ *
+ * The served reads are for display. For every type whose served reads the
+ * server translates (`TRANSLATABLE_METADATA_TYPES`, the predicate the REST
+ * read itself asks), `GET /meta/:type/:name?state=draft` answers the pending
+ * draft translated for the console's `Accept-Language`: a view's or a page's
+ * `label`, an app's navigation labels, a dashboard's widget titles. An object's
+ * draft read is governed besides, with the platform's injected columns (`owner_id`,
+ * `queue`, the audit and scope columns) in `fields`, and so is the layered read's
+ * `effective` for an object. An editor that seeded its buffer from the served
+ * draft and saved it back stored the translations as the author's text, and an
+ * object's injected columns as author fields.
+ *
+ * The author-owned document is the layered read's, spelled by the contract
+ * (`GetMetaItemLayeredResponseSchema.draft`): the `draft` layer, the pending
+ * draft row as stored, `null` when none is pending. A server serves it only to a
+ * caller its draft-read admission admits, and that same admission gates the
+ * `?state=draft` read, so a caller that was served a draft body was served the
+ * layer too. When the two disagree (a draft body served, no `draft` key on the
+ * layers) there is no author-owned copy of that draft to edit: the answer is
+ * `unserved`, the editor installs no buffer, and nothing is sent over the draft.
+ * ⛔ Never fall back to the served draft body there: that is the translated
+ * document this module exists to keep out of the buffer.
+ *
+ * With no draft pending, the buffer is the published item as authored
+ * ({@link authoredPublished}): an object's `overlay ?? code`, because its
+ * `effective` is governed; every other type's `effective ?? code`, which the
+ * layered read serves untranslated and which stays the server's own reading of
+ * the published item (the layered read decides it, not this module).
+ *
+ * It lives beside `MetadataClient.layered`, whose answer it reads, so every
+ * editor that saves a metadata item (Setup's and Studio's editors in
+ * `@object-ui/app-shell`, `@object-ui/plugin-designer`'s pages) reads it once.
+ *
+ * Display may stay translated: the projection reads (published field names,
+ * diagnostics, the header) keep reading what is served. Only the buffer moves.
+ */
+
+import { TRANSLATABLE_METADATA_TYPES } from '@objectstack/spec/system';
+
+/** The parts of the layered read this reading takes. */
+export interface AuthoredLayers {
+  code?: unknown;
+  overlay?: unknown;
+  effective?: unknown;
+  draft?: unknown;
+}
+
+export type AuthoredBuffer =
+  | {
+      kind: 'buffer';
+      /** The document the editor edits and saves. */
+      body: Record<string, unknown>;
+      /** True when `body` is the pending draft row. */
+      fromDraft: boolean;
+    }
+  | {
+      /** A draft is pending, and the layered read served no stored copy of it. */
+      kind: 'unserved';
+    };
+
+function asDocument(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/**
+ * Whether an editor of `type` takes its buffer from the layers: the served reads
+ * of the type are translated, so its served draft is not the author's document.
+ * Any other type's served draft is the stored row (`objectui#10765`), and its
+ * editors keep reading it.
+ */
+export function editsAuthoredLayers(type: string): boolean {
+  return TRANSLATABLE_METADATA_TYPES.has(type);
+}
+
+/**
+ * The editor's buffer for `type` from the layered read, and the draft body the
+ * `?state=draft` read served (`extractDraftBody`, `null` when none is pending).
+ * The served body only says whether a draft is pending; its content is never
+ * the buffer.
+ */
+export function authoredBuffer(
+  type: string,
+  layers: AuthoredLayers | null | undefined,
+  servedDraft: Record<string, unknown> | null,
+): AuthoredBuffer {
+  const stored = layers && 'draft' in layers ? asDocument(layers.draft) : null;
+  if (stored) return { kind: 'buffer', body: stored, fromDraft: true };
+  if (servedDraft) return { kind: 'unserved' };
+  return { kind: 'buffer', body: authoredPublished(type, layers), fromDraft: false };
+}
+
+/**
+ * The published item as its author wrote it: the buffer after a step that
+ * leaves no draft to edit (a discard, a reset, a publish that promoted it).
+ * An object's `overlay ?? code`; every other type's `effective ?? code`.
+ */
+export function authoredPublished(type: string, layers: AuthoredLayers | null | undefined): Record<string, unknown> {
+  if (type === 'object') return asDocument(layers?.overlay) ?? asDocument(layers?.code) ?? {};
+  return asDocument(layers?.effective) ?? asDocument(layers?.code) ?? {};
+}
@@ -7964,6 +7964,11 @@ export { MetadataClient, readSaveAdvisories } from './metadata-client';
 // `getDraft` that produces the envelope, because the unwrap-and-strip is part
 // of that method's contract rather than a detail of any one view.
 export { extractDraftBody } from './draft-envelope';
+// objectstack#29793, objectstack#30786 - the one reading of which document an
+// editor edits (the item as authored, from `layered()`), exported beside the
+// client whose answer it reads so every editor that saves an item asks it.
+export { authoredBuffer, authoredPublished, editsAuthoredLayers } from './authored-layers';
+export type { AuthoredBuffer, AuthoredLayers } from './authored-layers';
 // objectui#12725 - the reader of the same envelope's per-key provenance
 // (`draftChanges`, objectstack#24298): which surface last changed a key of the
 // pending draft. One reader, so the longest-prefix rule is spelled once.
 
@@ -91,6 +91,16 @@ vi.mock('./FieldDesigner', () => ({
 
 import { MetadataFieldsPage } from './MetadataFieldsPage';
 
+/**
+ * objectstack#30786 — the page takes its edit base off the layered read
+ * (`GET …/layers`, `overlay ?? code`), not the served item read, so this double
+ * answers that read: the item it used to serve becomes the `code` layer (and
+ * `effective`), beside the same envelope carriers.
+ */
+function servedAsLayers({ item, ...carriers }: { item: unknown } & Record<string, unknown>) {
+  return { ...carriers, code: item, overlay: null, effective: item };
+}
+
 let puts: Array<Record<string, unknown>> = [];
 
 function json(body: unknown, status = 200): Response {
@@ -110,15 +120,15 @@ function clientServing(fields: Record<string, Record<string, unknown>>): Metadat
         puts.push(JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>);
         return json({ success: true, name: 'probe_widget' });
       }
-      if (/\/meta\/object\/probe_widget(\?|$)/.test(url)) {
-        return json({
+      if (/\/meta\/object\/probe_widget\/layers(\?|$)/.test(url)) {
+        return json(servedAsLayers({
           type: 'object',
           name: 'probe_widget',
           item: { name: 'probe_widget', label: 'Widget', fields },
           lock: 'none',
           provenance: 'org',
           editable: true,
-        });
+        }));
       }
       return json({ items: [] });
     }) as unknown as typeof fetch,
 
@@ -35,6 +35,16 @@ vi.mock('@object-ui/plugin-form', async (importOriginal) => ({
 
 import { MetadataFieldsPage } from './MetadataFieldsPage';
 
+/**
+ * objectstack#30786 — the page takes its edit base off the layered read
+ * (`GET …/layers`, `overlay ?? code`), not the served item read, so this double
+ * answers that read: the item it used to serve becomes the `code` layer (and
+ * `effective`), beside the same envelope carriers.
+ */
+function servedAsLayers({ item, ...carriers }: { item: unknown } & Record<string, unknown>) {
+  return { ...carriers, code: item, overlay: null, effective: item };
+}
+
 /**
  * `code` is the field the author edits; `sku` carries the flag on a field the
  * author never opens; `title` is the control with no flag at all.
@@ -77,7 +87,7 @@ function realClient(): MetadataClient {
         puts.push(JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>);
         return json({ success: true, name: 'probe_widget' });
       }
-      if (/\/meta\/object\/probe_widget(\?|$)/.test(url)) return json(OBJECT_ENVELOPE);
+      if (/\/meta\/object\/probe_widget\/layers(\?|$)/.test(url)) return json(servedAsLayers(OBJECT_ENVELOPE));
       return json({ items: [] });
     }) as unknown as typeof fetch,
   });