@@ -0,0 +1,19 @@
+---
+'@objectstack/objectql': patch
+'@objectstack/metadata-protocol': patch
+---
+
+fix(objectql, metadata-protocol): a base package's own export carries its objects without its `.custom` pair's extension
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+After an administrator added a field to a vendor package's object through Studio's Customize (an extension published in `<base>.custom`, for example `region__c`, or a relabelled base field), `GET /api/v1/packages/<base>/export` carried that field and label inside the base's object, as if the vendor had shipped them. The pair's export carries the same extension as its `objectExtensions` entry, so installing the two exports elsewhere declared the customer's field twice, once as the vendor's. ADR-0146 D8 item 3 says the base's export carries the base unchanged.
+
+- **The base's export** (and its entry in `GET /api/v1/packages/export`) now carries each object as the base declares it, with no field, label or other patch from its pair's extension.
+- **The pair's export** is unchanged: it carries the extension in `objectExtensions`.
+- **Every served read is unchanged**: `GET /api/v1/meta/object/<name>`, the object list, the console and the data API keep serving the object with the pair's field and labels folded in.
+
+An extension contributed by any other installed package is still folded into the base's object in the base's export, as before.
+
+`SchemaRegistry.listItems` takes a `withoutExtensionsOf` option beside `includeDisabledPackages`, and `getAllObjects` and `foldObjectExtendersOnto` take the same option: each object is resolved with that package's `extend` contributions left out of the fold. Only the metadata protocol's per-package layer (the package export) passes it.
@@ -89,8 +89,20 @@ export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactL
     // and exports every package, enabled or not); the effective and the
     // execution reads hide them, at the registry and after the merges below.
     const keepDisabledPackages = layer === 'per-package';
+    // [#29903, ADR-0146 D8 item 3] …and it serves a package's objects as the
+    // package declares them: its `.custom` pair's extension of one is the
+    // pair's item, exported as the pair's `objectExtensions` entry, never
+    // folded into the base's object for the base's export (a field and its
+    // patches would travel twice, the second time as the base's). Every
+    // other contributor folds as on the effective read, and the effective
+    // and execution reads keep the pair's extension in the object they serve.
+    const pairOfLayer = layer === 'per-package' && packageId ? customizationPackageId(packageId) : undefined;
+    const withoutExtensionsOf = pairOfLayer?.ok ? pairOfLayer.value : undefined;
     const listRegistry = (type: string): unknown[] => (keepDisabledPackages
-        ? host.engine.registry.listItems(type, packageId, { includeDisabledPackages: true })
+        ? host.engine.registry.listItems(type, packageId, {
+            includeDisabledPackages: true,
+            ...(withoutExtensionsOf !== undefined ? { withoutExtensionsOf } : {}),
+        })
         : host.engine.registry.listItems(type, packageId));
     // ── [ADR-0131 D6] The environment → code read ──────────────────────
     //
@@ -251,8 +263,10 @@ export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactL
                 // object disagree the moment a row exists. Both routes were
                 // wrong here together, which is why #7556's byName===listed
                 // pin stayed green through this defect.
+                // [#29903] …without the package's pair's extension on the
+                // per-package layer, as its registry items are listed.
                 return host.foldObjectExtendersFromRegistry(
-                    request.type, (data as { name?: unknown } | null)?.name, data,
+                    request.type, (data as { name?: unknown } | null)?.name, data, withoutExtensionsOf,
                 );
             }, unseated, { servedOverride });
 
 
@@ -46,6 +46,7 @@ export function foldObjectExtendersFromRegistry(
     type: string,
     name: unknown,
     body: unknown,
+    withoutExtensionsOf?: string,
 ): unknown {
     const singular = PLURAL_TO_SINGULAR[type] ?? type;
     if (singular !== 'object') return body;
@@ -59,7 +60,11 @@ export function foldObjectExtendersFromRegistry(
     // cannot fold answers exactly as it did before.
     if (!registry || typeof registry.foldObjectExtendersOnto !== 'function') return body;
     try {
-        return registry.foldObjectExtendersOnto(name, body);
+        // [#29903] `withoutExtensionsOf`: that package's `extend` contributions
+        // are left out of the fold (the per-package layer names a base's pair).
+        return withoutExtensionsOf === undefined
+            ? registry.foldObjectExtendersOnto(name, body)
+            : registry.foldObjectExtendersOnto(name, body, { withoutExtensionsOf });
     } catch {
         // The fold is a read over in-memory contributors; a failure here
         // must not turn a served schema into a 5xx.
 
@@ -3526,13 +3526,13 @@ export class ObjectStackProtocolImplementation implements
      * (see {@link SchemaRegistry.foldObjectExtendersOnto}), so applying it twice
      * would duplicate both.
      */
-    private foldObjectExtendersFromRegistry(type: string, name: unknown, body: unknown): unknown {
+    private foldObjectExtendersFromRegistry(type: string, name: unknown, body: unknown, withoutExtensionsOf?: string): unknown {
         // [#25467 cut 30] The body moved to `protocol-object-extender-fold.ts` (see `ObjectExtenderFoldHost`).
         const readEngine = () => this.engine;
         const host: ThisParameterType<typeof foldObjectExtendersFromRegistry> = {
             get engine() { return readEngine(); },
         };
-        return foldObjectExtendersFromRegistry.call(host, type, name, body);
+        return foldObjectExtendersFromRegistry.call(host, type, name, body, withoutExtensionsOf);
     }
 
     /**
 
@@ -405,3 +405,50 @@ describe('ADR-0146 D10 — the manifest loop carries fieldPatches onto the exten
     expect(served.options[0]).toEqual({ value: 'tech', label: 'Technology' });
   });
 });
+
+describe('#29903 — a read can leave one package\'s extensions out of the fold', () => {
+  const PAIR_PKG = `${OWNER_PKG}.custom`;
+  /** The vendor's object, a third package's patch, and the pair's field plus its patch. */
+  function extended(): SchemaRegistry {
+    const reg = withVendor();
+    extend(reg, { name: { label: 'Account name' } });
+    reg.registerObject({
+      name: OBJ,
+      fields: { region__c: { name: 'region__c', type: 'text', label: 'Region' } },
+      fieldPatches: { industry: { label: 'Sector (customized)' } },
+    } as any, PAIR_PKG, undefined, 'extend', 300);
+    return reg;
+  }
+  const shape = (body: any) => ({
+    region: !!body?.fields?.region__c,
+    industry: body?.fields?.industry?.label,
+    name: body?.fields?.name?.label,
+  });
+  const listed = (reg: SchemaRegistry, options?: { withoutExtensionsOf?: string }) =>
+    (reg.listItems<any>('object', OWNER_PKG, options)).find((o) => o?.name === OBJ);
+
+  it('the listed object without the pair\'s extension is the object as no pair had extended it', () => {
+    const reg = extended();
+    expect(shape(listed(reg, { withoutExtensionsOf: PAIR_PKG }))).toEqual({ region: false, industry: 'Industry', name: 'Account name' });
+    expect(listed(reg, { withoutExtensionsOf: PAIR_PKG })?._packageId).toBe(OWNER_PKG);
+    // CONTROL: every other read of the object still folds the pair in.
+    expect(shape(listed(reg))).toEqual({ region: true, industry: 'Sector (customized)', name: 'Account name' });
+    expect(shape(reg.getObject(OBJ))).toEqual({ region: true, industry: 'Sector (customized)', name: 'Account name' });
+    // A package that extends nothing changes nothing: the cached merged object.
+    expect(listed(reg, { withoutExtensionsOf: 'com.nobody' })).toBe(reg.getObject(OBJ));
+  });
+
+  it('leaving the pair out is the answer a registry with no pair gives, byte for byte', () => {
+    const reg = withVendor();
+    extend(reg, { name: { label: 'Account name' } });
+    expect(JSON.stringify(listed(extended(), { withoutExtensionsOf: PAIR_PKG }))).toBe(JSON.stringify(listed(reg)));
+  });
+
+  it('the fold onto a stored body leaves the pair\'s extension out the same way', () => {
+    const reg = extended();
+    expect(shape(reg.foldObjectExtendersOnto(OBJ, vendorAccount(), { withoutExtensionsOf: PAIR_PKG })))
+      .toEqual({ region: false, industry: 'Industry', name: 'Account name' });
+    expect(shape(reg.foldObjectExtendersOnto(OBJ, vendorAccount())))
+      .toEqual({ region: true, industry: 'Sector (customized)', name: 'Account name' });
+  });
+});
@@ -721,6 +721,11 @@ function admittedFieldPatches(
  */
 type ServedObjectLayer = 'served' | 'code';
 
+/** [#29903] Whether `contributor` is an `extend` contribution of `packageId`. */
+function isExtensionOf(contributor: ObjectContributor, packageId: string | undefined): boolean {
+  return packageId !== undefined && contributor.ownership === 'extend' && contributor.packageId === packageId;
+}
+
 /**
  * Deep merge two ServiceObject definitions.
  *
@@ -4673,6 +4678,29 @@ export class SchemaRegistry {
     return merged;
   }
 
+  /**
+   * [#29903, ADR-0146 D8 item 3] An object as {@link resolveObject} resolves
+   * it, but with the `extend` contributions of `excludedPackageId` left out of
+   * the fold, as if that package had never extended it: the same base layer
+   * (`overlay ?? own`), every other extender folded in the same order, the same
+   * tail. With no such contribution it IS {@link resolveObject}'s answer (the
+   * cached body). Uncached otherwise, as {@link resolveOwnerLayer} is.
+   *
+   * The reader is the protocol's per-package layer, which serves a base's
+   * objects to the base's own export WITHOUT its `.custom` pair's extension:
+   * the base's export carries the base unchanged, and the pair's export carries
+   * the extension as its `objectExtensions` entry. Folded in, the pair's field
+   * and field patches travel twice, the second time as if the base shipped them.
+   */
+  private resolveObjectWithoutExtensionsOf(fqn: string, excludedPackageId: string | undefined): ServiceObject | undefined {
+    const contributors = excludedPackageId === undefined ? undefined : this.objectContributors.get(fqn);
+    if (!contributors || !contributors.some((c) => isExtensionOf(c, excludedPackageId))) return this.resolveObject(fqn);
+    const kept = contributors.filter((c) => !isExtensionOf(c, excludedPackageId));
+    const ownerContrib = kept.find(c => c.ownership === 'own');
+    if (!ownerContrib) return undefined;
+    return this.foldExtenders(kept, kept.find(c => c.ownership === 'overlay') ?? ownerContrib);
+  }
+
   /**
    * Fold every `extend` contribution over a chosen base layer, in the list's
    * (priority-sorted) order. Extracted from {@link resolveObject} so the
@@ -5477,15 +5505,19 @@ export class SchemaRegistry {
    * matching {@link resolveObject}, so this narrows nothing the fold was doing
    * on an unfolded base.
    */
-  foldObjectExtendersOnto<T>(name: string, base: T): T {
+  foldObjectExtendersOnto<T>(name: string, base: T, options?: { withoutExtensionsOf?: string }): T {
     if (base === null || typeof base !== 'object') return base;
     const fqn = this.resolveObjectKey(name);
     // With nothing to fold, the body still gets its picklist-bound fields
     // resolved — the same step the fold below ends with — so a body this
     // registry never saw is served in the one shape every other read uses.
     // By reference when no field names a picklist.
     if (fqn === undefined) return this.finishServedObject(base);
-    const contributors = this.objectContributors.get(fqn);
+    // [#29903] `options.withoutExtensionsOf`: that package's `extend`
+    // contributions are left out, as on {@link getAllObjects}.
+    const excluded = options?.withoutExtensionsOf;
+    const registered = this.objectContributors.get(fqn);
+    const contributors = excluded === undefined ? registered : registered?.filter((c) => !isExtensionOf(c, excluded));
     if (!contributors || !contributors.some((c) => c.ownership === 'extend')) return this.finishServedObject(base);
     return this.foldExtendersOntoDefinition(
       contributors,
@@ -6224,8 +6256,12 @@ export class SchemaRegistry {
    * Get all registered objects (merged).
    * 
    * @param packageId - Optional filter: only objects contributed by this package
+   * @param options.withoutExtensionsOf - [#29903] each object is resolved with
+   *   this package's `extend` contributions left out of the fold
+   *   ({@link resolveObjectWithoutExtensionsOf}). Only the protocol's
+   *   per-package layer passes it, naming the listed package's `.custom` pair.
    */
-  getAllObjects(packageId?: string): ServiceObject[] {
+  getAllObjects(packageId?: string, options?: { withoutExtensionsOf?: string }): ServiceObject[] {
     const results: ServiceObject[] = [];
 
     for (const fqn of this.objectContributors.keys()) {
@@ -6236,7 +6272,7 @@ export class SchemaRegistry {
         if (!hasContribution) continue;
       }
 
-      const merged = this.resolveObject(fqn);
+      const merged = this.resolveObjectWithoutExtensionsOf(fqn, options?.withoutExtensionsOf);
       if (merged) {
         // Tag with contributor info for UI
         (merged as any)._packageId = this.getObjectOwner(fqn)?.packageId;
@@ -7594,11 +7630,17 @@ export class SchemaRegistry {
    * items. Only the protocol's per-package layer passes it (the package
    * export, which carries a package's own items enabled or not); every
    * served read leaves it unset and hides them.
+   *
+   * [#29903] `options.withoutExtensionsOf` resolves each listed object with
+   * that package's `extend` contributions left out of the fold
+   * ({@link getAllObjects}); no other type reads it. Only the per-package
+   * layer passes it, naming the listed package's `.custom` pair, so a base's
+   * export carries the base's objects unchanged.
    */
-  listItems<T>(type: string, packageId?: string, options?: { includeDisabledPackages?: boolean }): T[] {
+  listItems<T>(type: string, packageId?: string, options?: { includeDisabledPackages?: boolean; withoutExtensionsOf?: string }): T[] {
     // Special handling for 'object' and 'objects' types - use objectContributors
     if (type === 'object' || type === 'objects') {
-      return this.getAllObjects(packageId) as unknown as T[];
+      return this.getAllObjects(packageId, { withoutExtensionsOf: options?.withoutExtensionsOf }) as unknown as T[];
     }
 
     const items = Array.from(this.metadata.get(type)?.values() || []) as T[];