@@ -0,0 +1,14 @@
+---
+'@objectstack/spec': patch
+---
+
+fix(spec): a served object keeps a field label and option labels that diverged from the packaged field, instead of overwriting them with the catalog
+
+Clause-②: no
+Metadata-protocol: none
+
+`translateObject` (and so `translateMetadataDocument('object', …)`, which the REST `/meta` reads call) wrote the catalog's field `label` and option labels over every served field. A published object extension's `fieldPatches` label (ADR-0146 D10) was therefore served only by `GET /meta/object/:name/layers`; the read naming no package, the read naming the base and the list read all served the shipped label.
+
+The two slots now follow the rule the field's `description`, `inlineHelpText` and `inlineTitle` and the object's own `label`, `pluralLabel` and `description` already follow (ADR-0029 D9.2a): the catalog applies only while the served value still equals the same field's, or the same option's, in the packaged base. With no packaged base the catalog applies as before. A picklist-bound field's options are the list's and keep the list's translations. A field the packaged base does not declare keeps its own label, as its other slots already did.
+
+Side effect: a tenant overlay's rename of a field label, or of an option label, is now served over the catalog as well, the same way an object rename has been.
@@ -0,0 +1,160 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [ADR-0146 D10 · ADR-0029 D9.2a] A published object extension's
+ * `fieldPatches` label survives the served `/meta` exit.
+ *
+ * The registry folds the patch onto every read of the base object
+ * (`registry-extension-field-patches.test.ts` pins that), but that pin reads
+ * registry bodies directly and never runs the localization this package
+ * applies on the way out. Measured on the booted showcase before the fix: the
+ * read naming no package, the read naming the base and the type's list all
+ * served the shipped field `label` and option label, because the catalog's
+ * entries (`objects.<object>.fields.<field>.label` / `.options.<value>`) were
+ * written over the folded body unconditionally; only the untranslated
+ * `/layers` showed the patch, and a patched `description` was served, since
+ * that slot already compared against the packaged field.
+ *
+ * So this pin runs the exit itself — {@link translateMetaDocument} (the item
+ * read) and {@link translateMetaList} (the list) — over a REAL
+ * `SchemaRegistry` carrying an owner and a patching extender, with the
+ * packaged base read the way the protocol reads it
+ * (`getPackagedObjectBase`, the owner's declaration before the fold). The
+ * rule itself is spec's (`i18n-resolver.test.ts`); what only this layer can
+ * show is that the folded body and the pre-fold base both reach it.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { SchemaRegistry } from '@objectstack/objectql';
+import { translateMetaDocument, translateMetaList, type MetaListTranslationSources } from './meta-item-read-gate.js';
+
+const OWNER_PKG = 'com.example.showcase';
+const EXT_PKG = 'com.example.showcase.custom';
+const OBJ = 'showcase_task';
+
+function owner(): any {
+    return {
+        name: OBJ,
+        label: 'Task',
+        fields: {
+            title: { name: 'title', type: 'text', label: 'Title', description: 'What the task is.' },
+            status: {
+                name: 'status',
+                type: 'select',
+                label: 'Status',
+                options: [
+                    { value: 'todo', label: 'To Do' },
+                    { value: 'done', label: 'Done' },
+                ],
+            },
+        },
+    };
+}
+
+/** The extension's patch, the shape the dev report measured on the showcase. */
+const PATCH = {
+    title: { label: 'Headline', description: 'Patched description' },
+    status: { options: { todo: { label: 'Queued' } } },
+};
+
+/** `en` repeats the packaged strings (what `i18n:extract` writes); `zh-CN` translates them. */
+const BUNDLE: Record<string, any> = {
+    en: {
+        objects: {
+            [OBJ]: {
+                label: 'Task',
+                fields: {
+                    title: { label: 'Title' },
+                    status: { label: 'Status', options: { todo: 'To Do', done: 'Done' } },
+                },
+            },
+        },
+    },
+    'zh-CN': {
+        objects: {
+            [OBJ]: {
+                label: '任务',
+                fields: {
+                    title: { label: '标题' },
+                    status: { label: '状态', options: { todo: '待办', done: '已完成' } },
+                },
+            },
+        },
+    },
+};
+
+const i18nService = {
+    getLocales: () => ['en', 'zh-CN'],
+    getTranslations: (locale: string) => BUNDLE[locale],
+    getDefaultLocale: () => 'en',
+};
+
+function registry(withPatch: boolean): SchemaRegistry {
+    const reg = new SchemaRegistry({ multiTenant: false, searchCompanion: false } as never);
+    reg.logLevel = 'silent';
+    reg.registerObject(owner(), OWNER_PKG, undefined, 'own');
+    if (withPatch) reg.registerObject({ name: OBJ, fieldPatches: PATCH } as any, EXT_PKG, undefined, 'extend', 200);
+    return reg;
+}
+
+/** The transport's sources, with the protocol's packaged-base accessor over the registry. */
+function sources(reg: SchemaRegistry, locale: string): MetaListTranslationSources {
+    const protocol = { getPackagedObjectBase: (name: string) => reg.getPackagedObjectBase(name) };
+    return {
+        resolveI18nService: async () => i18nService,
+        resolveProtocol: async () => protocol,
+        requestLocale: () => locale,
+    };
+}
+
+/** The served (folded) body, as the protocol's reads hand it to the exit. */
+const served = (reg: SchemaRegistry) => structuredClone(reg.getObject(OBJ)) as any;
+
+const titleOf = (doc: any) => doc.fields.title;
+const todoOf = (doc: any) => doc.fields.status.options.find((o: any) => o.value === 'todo');
+const doneOf = (doc: any) => doc.fields.status.options.find((o: any) => o.value === 'done');
+
+describe('a published fieldPatches label survives the served /meta exit', () => {
+    it('the registry folds the patch, and the packaged base is the pre-fold owner', () => {
+        // The premise of every case below, read off the same registry: if
+        // either half moved, the cases would pass or fail for another reason.
+        const reg = registry(true);
+        expect(titleOf(served(reg)).label).toBe('Headline');
+        expect(todoOf(served(reg)).label).toBe('Queued');
+        const base: any = reg.getPackagedObjectBase(OBJ);
+        expect(base.fields.title.label).toBe('Title');
+        expect(base.fields.status.options[0].label).toBe('To Do');
+    });
+
+    for (const locale of ['zh-CN', 'en']) {
+        it(`the item read serves the patched field and option labels (${locale})`, async () => {
+            const reg = registry(true);
+            const out: any = await translateMetaDocument(sources(reg, locale), 'object', served(reg));
+            expect(titleOf(out).label).toBe('Headline');
+            expect(titleOf(out).description).toBe('Patched description');
+            expect(todoOf(out).label).toBe('Queued');
+        });
+
+        it(`the list read serves them too (${locale})`, async () => {
+            const reg = registry(true);
+            const out: any = await translateMetaList(sources(reg, locale), 'object', [served(reg)]);
+            expect(titleOf(out[0]).label).toBe('Headline');
+            expect(todoOf(out[0]).label).toBe('Queued');
+        });
+    }
+
+    it('the slots the patch leaves alone are still translated', async () => {
+        const reg = registry(true);
+        const out: any = await translateMetaDocument(sources(reg, 'zh-CN'), 'object', served(reg));
+        expect(out.label).toBe('任务');
+        expect(out.fields.status.label).toBe('状态');
+        expect(doneOf(out).label).toBe('已完成');
+    });
+
+    it('with no extension, the shipped labels are translated as before', async () => {
+        const reg = registry(false);
+        const out: any = await translateMetaDocument(sources(reg, 'zh-CN'), 'object', served(reg));
+        expect(titleOf(out).label).toBe('标题');
+        expect(todoOf(out).label).toBe('待办');
+    });
+});
@@ -3878,11 +3878,13 @@ describe('translateObject — catalog vs explicit override', () => {
     expect(zh({ name: 'showcase_account', label: '' }, PACKAGED).label).toBe('客户');
   });
 
-  it('leaves FIELD labels alone — the rule is scoped to the three scalars', () => {
-    // Field labels have their own per-field catalog keys and no measured
-    // divergence; widening the rule to them would be a second change riding
-    // this one.
-    const withFields = {
+  it('judges a FIELD label by the same rule, against the same field in the packaged base', () => {
+    // A field `label` is authored on top of the packaged declaration too — an
+    // extension's `fieldPatches` label, a tenant's rename — so the scalar rule
+    // reaches it, judged per field. The full truth table is the field-label
+    // block below.
+    const packaged = { ...PACKAGED, fields: { industry: { name: 'industry', type: 'select', label: 'Industry' } } };
+    const served = {
       ...PACKAGED,
       label: 'Customer',
       fields: { industry: { name: 'industry', type: 'select', label: 'Vertical' } },
@@ -3894,9 +3896,9 @@ describe('translateObject — catalog vs explicit override', () => {
         },
       } as any,
     };
-    const out = translateObject(withFields, bundle, { locale: 'zh-CN', packagedBase: PACKAGED });
+    const out = translateObject(served, bundle, { locale: 'zh-CN', packagedBase: packaged });
     expect(out.label).toBe('Customer');
-    expect((out.fields as any).industry.label).toBe('行业');
+    expect((out.fields as any).industry.label).toBe('Vertical');
   });
 
   it('does not mutate either input document', () => {
@@ -3921,6 +3923,164 @@ describe('translateObject — catalog vs explicit override', () => {
   });
 });
 
+// ────────────────────────────────────────────────────────────────────────────
+// translateObject — a field label and its option labels yield to a diverged
+// value (ADR-0029 D9.2a, ADR-0146 D10 `fieldPatches`)
+// ────────────────────────────────────────────────────────────────────────────
+
+/**
+ * A published object extension's `fieldPatches` label (ADR-0146 D10) is folded
+ * onto every read of the base object, but the served read localized the
+ * folded body with the catalog's field `label` and option labels written
+ * unconditionally, so the bare, base-named and list reads kept the shipped
+ * text and only the untranslated `/layers` showed the patch. The two slots now
+ * follow the comparison their sibling slots (`description`, `inlineHelpText`,
+ * `inlineTitle`) and the object scalars already follow.
+ */
+describe('translateObject — a field label and its option labels yield to a diverged value', () => {
+  /** The packaged declaration: the owner's fields, as the owner contributor holds them. */
+  const PACKAGED = {
+    name: 'showcase_task',
+    label: 'Task',
+    fields: {
+      title: { name: 'title', type: 'text', label: 'Title' },
+      status: {
+        name: 'status',
+        type: 'select',
+        label: 'Status',
+        options: [
+          { value: 'todo', label: 'To Do' },
+          { value: 'done', label: 'Done' },
+        ],
+      },
+      created_at: { name: 'created_at', type: 'datetime', label: 'Created At' },
+    },
+  };
+
+  /** `en` repeats the packaged strings (what `i18n:extract` writes); `zh-CN` translates them. */
+  const BUNDLE: TranslationBundle = {
+    en: {
+      objects: {
+        showcase_task: {
+          label: 'Task',
+          fields: {
+            title: { label: 'Title' },
+            status: { label: 'Status', options: { todo: 'To Do', done: 'Done' } },
+          },
+        },
+      },
+    } as any,
+    'zh-CN': {
+      objects: {
+        showcase_task: {
+          label: '任务',
+          fields: {
+            title: { label: '标题' },
+            status: { label: '状态', options: { todo: '待办', done: '已完成' } },
+          },
+        },
+      },
+    } as any,
+  };
+
+  const clone = <T>(value: T): T => structuredClone(value);
+  const fieldsOf = (out: unknown) => (out as { fields: Record<string, any> }).fields;
+  /** The served body after an extension's `fieldPatches` relabelled `title` and the `todo` option. */
+  const patched = () => {
+    const served = clone(PACKAGED) as any;
+    served.fields.title.label = 'Headline';
+    served.fields.status.options[0].label = 'Queued';
+    return served;
+  };
+
+  it('keeps a patched field label and option label, in every locale, through the type dispatch', () => {
+    // The REST exit reaches `translateObject` through the dispatcher, so the
+    // base must arrive there for the comparison to be made at all.
+    for (const locale of ['en', 'zh-CN']) {
+      const fields = fieldsOf(
+        translateMetadataDocument('object', patched(), BUNDLE, { locale, packagedBase: PACKAGED }),
+      );
+      expect(fields.title.label).toBe('Headline');
+      expect(fields.status.options[0].label).toBe('Queued');
+    }
+  });
+
+  it('judges per field and per option: the undiverged siblings are still translated', () => {
+    const fields = fieldsOf(translateObject(patched(), BUNDLE, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(fields.status.label).toBe('状态');
+    expect(fields.status.options[1].label).toBe('已完成');
+  });
+
+  it('an untouched document still gets the catalog on both slots', () => {
+    const fields = fieldsOf(translateObject(clone(PACKAGED), BUNDLE, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(fields.title.label).toBe('标题');
+    expect(fields.status.options.map((o: any) => o.label)).toEqual(['待办', '已完成']);
+  });
+
+  it('with no packaged base, the catalog applies — "unknown" is not "authored"', () => {
+    for (const packagedBase of [undefined, null]) {
+      const fields = fieldsOf(translateObject(patched(), BUNDLE, { locale: 'zh-CN', packagedBase }));
+      expect(fields.title.label).toBe('标题');
+      expect(fields.status.options[0].label).toBe('待办');
+    }
+  });
+
+  it('an absent or empty served label is not an override — the catalog fills it', () => {
+    const served = clone(PACKAGED) as any;
+    delete served.fields.title.label;
+    served.fields.status.options[0].label = '';
+    const fields = fieldsOf(translateObject(served, BUNDLE, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(fields.title.label).toBe('标题');
+    expect(fields.status.options[0].label).toBe('待办');
+  });
+
+  it('a field or option the packaged base does not declare counts as diverged', () => {
+    const served = clone(PACKAGED) as any;
+    served.fields.extra = { name: 'extra', type: 'text', label: 'Extra' };
+    served.fields.status.options.push({ value: 'blocked', label: 'Blocked' });
+    const bundle = clone(BUNDLE) as any;
+    bundle['zh-CN'].objects.showcase_task.fields.extra = { label: '额外' };
+    bundle['zh-CN'].objects.showcase_task.fields.status.options.blocked = '受阻';
+    const fields = fieldsOf(translateObject(served, bundle, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(fields.extra.label).toBe('Extra');
+    expect(fields.status.options[2].label).toBe('Blocked');
+  });
+
+  it("a picklist-bound field's options have no field-level baseline — the list's labels still apply", () => {
+    // The served options are the LIST's, resolved onto the served field on
+    // every read; the packaged field names the list and carries none.
+    const packaged = {
+      ...PACKAGED,
+      fields: { ...PACKAGED.fields, stage: { name: 'stage', type: 'select', label: 'Stage', picklist: 'task_stage' } },
+    };
+    const served = clone(packaged) as any;
+    served.fields.stage.options = [{ value: 'new', label: 'New' }];
+    const bundle: TranslationBundle = {
+      'zh-CN': { picklists: { task_stage: { options: { new: '新建' } } } } as any,
+    };
+    const fields = fieldsOf(translateObject(served, bundle, { locale: 'zh-CN', packagedBase: packaged }));
+    expect(fields.stage.options[0].label).toBe('新建');
+  });
+
+  it('an undiverged injected system field keeps its built-in label; a diverged one keeps its text', () => {
+    const untouched = fieldsOf(translateObject(clone(PACKAGED), BUNDLE, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(untouched.created_at.label).toBe('创建时间');
+    const served = clone(PACKAGED) as any;
+    served.fields.created_at.label = 'Logged At';
+    const renamed = fieldsOf(translateObject(served, BUNDLE, { locale: 'zh-CN', packagedBase: PACKAGED }));
+    expect(renamed.created_at.label).toBe('Logged At');
+  });
+
+  it('does not mutate either input document', () => {
+    const served = patched();
+    const before = clone(served);
+    const base = clone(PACKAGED);
+    translateObject(served, BUNDLE, { locale: 'zh-CN', packagedBase: base });
+    expect(served).toEqual(before);
+    expect(base).toEqual(PACKAGED);
+  });
+});
+
 // ────────────────────────────────────────────────────────────────────────────
 // translateObject — a field's translated help is served on `description` (#21948)
 // and on an authored `inlineHelpText` (#29153)