@@ -0,0 +1,19 @@
+---
+'@objectstack/spec': minor
+'@objectstack/metadata-protocol': minor
+'@objectstack/rest': minor
+'@objectstack/runtime': minor
+---
+
+feat(metadata): the layered read takes the bundle member selector, so the layers of one locale of an `email_template` can be read
+
+Clause-②: yes
+Metadata-protocol: added
+
+`GET /api/v1/meta/:type/:name/layers` and the protocol's `getMetaItemLayered` now accept `member`, the same bundle member selector the by-name read, delete, publish, history and revert already take. Before, the layered view only ever showed the canonical member (`en-US` for `email_template`) and refused `?member=` with 400, so an editor built on it could not open a second locale of a template.
+
+- **Named the same way.** `?member=` on the REST route and `member` on `GetMetaItemLayeredRequest` (`@objectstack/spec`), spelled as the member's discriminator value (`zh-CN`). Absent, the canonical member's layers, as before; naming the canonical value is the same request.
+- **Every layer is that member's.** `code` is the package's artifact for that member, `overlay` the environment's stored row for that member, and `effective` what the by-name read with the same `member` serves. A member with nothing shipped and nothing stored answers `404`, the absent item, never the canonical member's layers.
+- **Refused as the item read refuses it.** A `member` on a type whose identity is its name alone (every type but `email_template` today), a blank one, or one over 100 characters is a `400 VALIDATION_ERROR` naming the selector. A repeated `?member=` is refused by the multiplicity rule.
+- **Both transports.** `RestServer`'s route and the runtime dispatcher's `/meta` catch-all judge the route's query through the one shared decision (`metaItemQueryRefusal('layers', …)` in `@objectstack/rest`), whose closed set for the route is now `package` and `member`. `META_ITEM_LAYERS_PARAMS` reads `['package', 'member']`.
+- **Unchanged.** The deprecated `?layers=` flag on the plain read still refuses a `member` beside it; read one member's layers on `/layers` instead.
@@ -1380,6 +1380,7 @@ This schema accepts one of the following structures:
 | **type** | `string` | ✅ | Metadata type name |
 | **name** | `string` | ✅ | Item name |
 | **packageId** | `string` | optional | Optional package ID — scopes the `code` layer so a same-name collision resolves to the requested package's artifact (ADR-0048). |
+| **member** | `string` | optional | Bundle member selector, for a metadata type whose identity is a pair (today only `email_template`, identified by `(name, locale)`): the member this request addresses, spelled as its discriminator value (`zh-CN`). Absent, the canonical member (`en-US` for `email_template`), which is what a bare-name read answers; naming the canonical value is the same request. It is not the response translation locale, which `?locale=` and `Accept-Language` choose. Refused with 400 `VALIDATION_ERROR` on a type that has no members, and for a blank value or one longer than a stored member can be (100 characters). A well-formed member with nothing stored or shipped answers as that door answers an absent item. |
 
 
 ---
 
@@ -101,8 +101,8 @@ const SITES: ReadonlyArray<Site & { readonly noPackage: boolean; readonly dispos
         why: 'the shipped-flow arm: the served body IS this artifact, and the envelope is looked up at its own package' },
     { member: 'readMetaItem', args: 'request.type, request.name, request.packageId, wantedMember', noPackage: true, disposition: 'no',
         why: '[#22877] a bundled type\'s addressed member (the selector\'s, else the canonical one) when no stored row of it exists: the served body IS this artifact, and the envelope is looked up at its own package' },
-    { member: 'getMetaItemLayered', args: 'request.type, request.name, request.packageId', noPackage: true, disposition: 'no',
-        why: 'the layered read\'s code LAYER: body and envelope are one artifact, and its provenance fields are read off that layer' },
+    { member: 'getMetaItemLayered', args: 'request.type, request.name, request.packageId, wantedMember', noPackage: true, disposition: 'no',
+        why: 'the layered read\'s code LAYER: body and envelope are one artifact, and its provenance fields are read off that layer; [#26699] at the addressed member (the selector\'s, else the canonical one)' },
     { member: 'packagedArtifactBase', args: 'type, name', noPackage: true, disposition: 'no',
         why: 'the packaged base the translators compare a served body against: nothing of it is grafted onto the body' },
     { member: 'readCodeLayerForCarryForward', args: 'type, name, pkg', noPackage: true, disposition: 'no',
 
@@ -11400,6 +11400,8 @@ export class ObjectStackProtocolImplementation implements
         type: string;
         name: string;
         packageId?: string;
+        /** [#26699] The bundle member whose layers to read — {@link resolveBundleMemberSelector}; omitted, the canonical one. */
+        member?: string;
     }): Promise<{
         type: string;
         name: string;
@@ -11446,6 +11448,18 @@ export class ObjectStackProtocolImplementation implements
         if (request.type === 'object' && isObjectOfDisabledPackage(this.engine?.registry, request.name)) {
             throw objectPackageDisabledError(request.name);
         }
+        // [#26699] Ruling 6116165299 (Q2 i), extended to this read by the
+        // option-A ruling on #26649: ONE member of a bundled type, the
+        // selector's or else the canonical one, read exactly as
+        // {@link getMetaItem} reads it. Every layer below is that member's or
+        // nothing — the code layer's service copy, artifact and registry entry,
+        // and the stored row — so a named member nothing holds answers no
+        // layer, which the door answers as an absent item, ⛔ never with the
+        // canonical member's layers.
+        const member = resolveBundleMemberSelector(request.type, request.member);
+        const wantedMember = bundleMemberDiscriminator(request.type, member);
+        const isWantedMember = (candidate: unknown): boolean =>
+            wantedMember === undefined || itemDiscriminator(request.type, candidate) === wantedMember;
 
         // [ADR-0131 D6] Environment → code: the overlay layer is the
         // environment's stored row; no organization's row is read.
@@ -11462,15 +11476,22 @@ export class ObjectStackProtocolImplementation implements
                 request.packageId,
             );
             if (fromService.data !== undefined && fromService.data !== null) {
+                // [#26699] …when it is the member this read addresses, as in
+                // {@link getMetaItem}: the service keys a type's items by name
+                // alone, so for a bundle it holds whichever member it
+                // registered last. Another member's copy is no layer of this
+                // one; the artifact and registry lookups below ask for it.
                 // [#7556] The CODE layer of an object is D9.6's "owner's
                 // declaration with its extenders folded on", so the
                 // MetadataService copy is its base, not the layer itself.
                 // `effective` is `overlay ?? code`, so an object with no
                 // overlay row — the ordinary shape — is corrected by this
                 // single fold on both layers the diagnostic reports.
-                code = this.foldObjectExtendersFromRegistry(
-                    request.type, request.name, fromService.data,
-                );
+                if (isWantedMember(fromService.data)) {
+                    code = this.foldObjectExtendersFromRegistry(
+                        request.type, request.name, fromService.data,
+                    );
+                }
             } else if (fromService.degraded) {
                 // [#5840] Kept, not swallowed — acted on after the registry
                 // fallback below, which may still produce a real code layer.
@@ -11509,13 +11530,25 @@ export class ObjectStackProtocolImplementation implements
             // item-lock resolution below). A
             // runtime-registered item with no package carries no tenant marker
             // and keeps its code layer.
+            //
+            //
+            // [#26699] Each lookup is asked for the addressed member, exactly
+            // as {@link getMetaItem}'s are: the artifact at the member (the
+            // canonical one when none was named), and the registry for the
+            // member named. The registry's bare-name read still answers a
+            // bundle that ships no canonical member; a registry that does not
+            // narrow by member can answer another one for a NAMED member, and
+            // that answer is not this member's layer.
             const runtimeOnly = (item: unknown): unknown =>
                 item !== undefined && isTenantAuthored(item) ? undefined : item;
-            let regItem = this.lookupArtifactItem(request.type, request.name, request.packageId)
-                ?? runtimeOnly(this.engine.registry.getItem(request.type, request.name, request.packageId));
+            const namedMemberOnly = (item: unknown): unknown =>
+                member !== undefined && item !== undefined && !isWantedMember(item) ? undefined : item;
+            const artifact = this.lookupArtifactItem(request.type, request.name, request.packageId, wantedMember);
+            let regItem = (artifact !== undefined && isWantedMember(artifact) ? artifact : undefined)
+                ?? namedMemberOnly(runtimeOnly(this.engine.registry.getItem(request.type, request.name, request.packageId, member)));
             if (regItem === undefined) {
                 const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
-                if (alt) regItem = runtimeOnly(this.engine.registry.getItem(alt, request.name, request.packageId));
+                if (alt) regItem = namedMemberOnly(runtimeOnly(this.engine.registry.getItem(alt, request.name, request.packageId, member)));
             }
             if (regItem !== undefined) code = regItem;
         }
@@ -11558,15 +11591,17 @@ export class ObjectStackProtocolImplementation implements
         // lock stays at the request's address, as the `_lock` gate judges it.
         // Asked outside the `try` below: its own failed read already answers
         // the #5532 envelope, with the driver's error as `cause`.
-        const contentPackageId = request.packageId || await this.packagelessReadAddress(request.type, request.name);
+        const contentPackageId = request.packageId || await this.packagelessReadAddress(request.type, request.name, member);
         try {
             // ADR-0048 prefer-local. [#21716] The ONE served-row resolution
             // {@link getMetaItem} calls too — see {@link findServedOverlayRow}.
+            // [#26699] At the addressed member, as that read asks it.
             const served = await this.findServedOverlayRow({
                 type: request.type,
                 name: request.name,
                 state: 'active',
                 ...(contentPackageId ? { packageId: contentPackageId } : {}),
+                ...memberOption(member),
             });
             overlayLockLayer = await this.overlayLockLayerAt({
                 type: request.type,
 
@@ -497,6 +497,74 @@ describe('the by-name doors address ONE member by the selector (#22877, stage 2)
     });
 });
 
+// [#26699] The layered read (`getMetaItemLayered`, the Setup editor's read
+// through `GET /meta/:type/:name/layers`) takes the same selector: the option-A
+// ruling on #26649 extended ruling 6116165299's door list to it.
+const layersOf = async (protocol: ObjectStackProtocolImplementation, member?: string) => {
+    const layered: any = await protocol.getMetaItemLayered({ type: T, name: NAME, ...(member !== undefined ? { member } : {}) });
+    return {
+        code: layered?.code?.subject ?? null,
+        overlay: layered?.overlay?.subject ?? null,
+        effective: layered?.effective?.subject ?? null,
+        overlayScope: layered?.overlayScope ?? null,
+    };
+};
+
+describe('[#26699] the layered read addresses ONE member by the selector', () => {
+    it('a non-canonical member answers its own code and overlay layers', async () => {
+        const stores = new Map<string, Map<string, Record<string, unknown>>>();
+        const { protocol } = await bootWithBothSaved(stores);
+        expect(await layersOf(protocol, 'zh-CN')).toEqual({
+            code: 'PKG zh', overlay: 'ADMIN zh', effective: 'ADMIN zh', overlayScope: 'env',
+        });
+        // A member nobody stored: its own code layer, and no overlay — never the canonical row.
+        const fresh = await boot(new Map());
+        await fresh.protocol.saveMetaItem({ type: T, name: NAME, item: template('en-US', 'ADMIN en') });
+        expect(await layersOf(fresh.protocol, 'zh-CN')).toEqual({
+            code: 'PKG zh', overlay: null, effective: 'PKG zh', overlayScope: null,
+        });
+    });
+
+    it('CONTROL: the canonical read is unchanged — absent, and the canonical value, answer the canonical member', async () => {
+        const stores = new Map<string, Map<string, Record<string, unknown>>>();
+        const { protocol } = await bootWithBothSaved(stores);
+        const canonical = { code: 'PKG en', overlay: 'ADMIN en', effective: 'ADMIN en', overlayScope: 'env' };
+        expect(await layersOf(protocol)).toEqual(canonical);
+        expect(await layersOf(protocol, 'en-US')).toEqual(canonical);
+        // The whole answer, not only the subjects: naming the canonical value is the same request.
+        expect(await protocol.getMetaItemLayered({ type: T, name: NAME, member: 'en-US' }))
+            .toEqual(await protocol.getMetaItemLayered({ type: T, name: NAME }));
+    });
+
+    it('the MetadataService copy is a code layer only of the member it is — the canonical read never reports another member\'s', async () => {
+        // The service keys a type's items by name alone, so for a bundle it
+        // holds whichever member registered last: here, zh-CN.
+        const stores = new Map<string, Map<string, Record<string, unknown>>>();
+        const { engine } = await bootWithBothSaved(stores);
+        const metadata = { get: async () => template('zh-CN', 'SVC zh') };
+        const withService = new ObjectStackProtocolImplementation(engine, () => new Map([['metadata', metadata]]), 'env_prod');
+        expect((await layersOf(withService)).code).toBe('PKG en');
+        expect((await layersOf(withService, 'en-US')).code).toBe('PKG en');
+        expect((await layersOf(withService, 'zh-CN')).code).toBe('SVC zh');
+    });
+
+    it('a member no layer holds answers no layer at all — the door\'s absent item, never the canonical member', async () => {
+        const stores = new Map<string, Map<string, Record<string, unknown>>>();
+        const { protocol } = await bootWithBothSaved(stores);
+        expect(await layersOf(protocol, 'fr-FR')).toEqual({ code: null, overlay: null, effective: null, overlayScope: null });
+    });
+
+    it('a wrong selector is the located 400 of the one reading, and nothing is read', async () => {
+        const stores = new Map<string, Map<string, Record<string, unknown>>>();
+        const { protocol } = await bootWithBothSaved(stores);
+        await expectSelectorRefusal(
+            protocol.getMetaItemLayered({ type: 'view', name: 'task_grid', member: 'zh-CN' }),
+            /^The "member" selector names a bundle member, and a 'view' item has none/,
+        );
+        await expectSelectorRefusal(protocol.getMetaItemLayered({ type: T, name: NAME, member: ' ' }), /^The "member" selector is blank\./);
+    });
+});
+
 describe('the package-batch doors and the cluster fan-out carry the member (#22877, stage 2)', () => {
     /** A zh-CN draft bound to the package, beside an en-US active overlay that has none. */
     async function bootWithZhDraft(stores: Map<string, Map<string, Record<string, unknown>>>) {
 
@@ -35,9 +35,11 @@ const LAYERED_MEMBER = 'The "member" selector is not served by the layered view
 const refusal = (rule: string, message: string) => ({ status: 400, code: 'VALIDATION_ERROR', message, rule });
 
 describe('[#23072] metaItemQueryRefusal — each door\'s closed set', () => {
-    it('the measured sets: the item read\'s six, `/layers`\' one, `/published`\' none, and the dispatcher save\'s three (no `force`)', () => {
+    it('the measured sets: the item read\'s six, `/layers`\' two, `/published`\' none, and the dispatcher save\'s three (no `force`)', () => {
         expect([...META_ITEM_READ_PARAMS].sort()).toEqual(['layers', 'locale', 'member', 'package', 'preview', 'state']);
-        expect([...META_ITEM_LAYERS_PARAMS]).toEqual(['package']);
+        // [#26699] The bundle member selector joined `/layers` (ruling 6116165299's
+        // door list, extended to the layered read by the option-A ruling on #26649).
+        expect([...META_ITEM_LAYERS_PARAMS]).toEqual(['package', 'member']);
         expect([...META_ITEM_PUBLISHED_PARAMS]).toEqual([]);
         // RestServer's own save door reads `force`; the dispatcher's does not.
         // [#24395] `surface` joined both save doors' sets.
@@ -76,11 +78,13 @@ describe('[#23072] metaItemQueryRefusal — each door\'s closed set', () => {
         });
     }
 
-    it('`member` is refused by every door that does not read it — the layered view, the published document and the body-addressed save', () => {
-        for (const door of ['layers', 'published', 'save'] as const) {
+    it('`member` is refused by every door that does not read it — the published document and the body-addressed save', () => {
+        for (const door of ['published', 'save'] as const) {
             expect(metaItemQueryRefusal(door, { member: 'zh-CN' })?.rule, door).toBe('unknown-parameter');
         }
         expect(metaItemQueryRefusal('item', { member: 'zh-CN' })).toBeUndefined();
+        // [#26699] The layered view reads it now.
+        expect(metaItemQueryRefusal('layers', { member: 'zh-CN' })).toBeUndefined();
     });
 });
 
@@ -92,6 +96,10 @@ describe('[#23072] metaItemQueryRefusal — arity, and the order of the three ru
         expect(metaItemQueryRefusal('layers', { package: ['a', 'b', 'c'] })).toEqual(refusal(
             'repeated-parameter', repeatedQueryParamMessage('package', 3),
         ));
+        // [#26699] …and the member the layered view now reads, once.
+        expect(metaItemQueryRefusal('layers', { member: ['zh-CN', 'ja-JP'] })).toEqual(refusal(
+            'repeated-parameter', repeatedQueryParamMessage('member', 2),
+        ));
         expect(metaItemQueryRefusal('save', { mode: ['draft', 'active'] })?.message)
             .toBe(repeatedQueryParamMessage('mode', 2));
     });