@@ -0,0 +1,17 @@
+---
+'@objectstack/metadata-protocol': patch
+'@objectstack/rest': patch
+'@objectstack/runtime': patch
+---
+
+fix(metadata-protocol,rest,runtime): `GET /meta/:type/:name/layers` serves the pending draft as stored, so an editor re-opens an author's draft without translations or injected columns (#29814)
+
+Clause-②: no
+Metadata-protocol: none
+
+The layered view now serves the `draft` layer that `GetMetaItemLayeredResponseSchema` declares, on `RestServer` and on the runtime dispatcher, and on the deprecated `?layers=` spelling too. Before, the only read of a pending draft was `?state=draft`, which serves it translated for the caller's locale and governed (the platform's injected columns added), so an editor that built its buffer from it and saved it back wrote translations and platform columns into the author's draft.
+
+- **What `draft` is.** The row the `?state=draft` read serves, at the same address (`?package=` picks that package's draft), exactly as stored: converted like the `overlay` layer and credential-redacted like every layer, never translated, governed or stamped. `null` when no draft is pending. An edit buffer reads `draft ?? overlay ?? code`.
+- **Who is served it.** Only a caller the draft-read admission already admits (the predicate every draft read asks: a system caller, `studio.access`, `setup.access` or `manage_metadata`). The per-caller gate judges it like the other layers: whole for whoever may write the item, pruned as `?state=draft` prunes it otherwise. Any other caller is answered the layers with no `draft` key, which says nothing about whether a draft exists, and a name with only a draft stays a `404` for them.
+- **Unchanged.** `?state=draft` and every other read answer as before. A never-published name an admitted author holds a draft of is now answered `200` with only its `draft` layer, where it was a `404`.
+- **Protocol.** `getMetaItemLayered(request, { withDraft: true })` reads the layer; without the option the answer carries no `draft` key, so its in-process readers read no draft.
@@ -76,19 +76,25 @@ export async function packagelessLayeredReadRefusal(host: Pick<ProtocolHost, 'pa
 }
 
 /** The body of `ObjectStackProtocolImplementation#getMetaItemLayered`; the method's docblock there is its contract. */
-export async function getMetaItemLayered(host: Pick<ProtocolHost, 'artifactLockLayerAt' | 'convertStoredItem' | 'declinesStoredRow' | 'engine' | 'findPairAddedMemberRow' | 'findServedOverlayRow' | 'foldObjectExtendersFromRegistry' | 'governServedObject' | 'isArtifactBacked' | 'lookupArtifactItem' | 'overlayLockLayerAt' | 'packagelessReadAddress' | 'readItemActiveRows' | 'readItemFromMetadataService' | 'resolveRowlessExpandedView' | 'resolveWritePackageScope' | 'rethrowUnlessMetadataStoreUnprovisioned' | 'servedLockState' | 'throwMetadataServiceUnavailable'>, request: {
+export async function getMetaItemLayered(host: Pick<ProtocolHost, 'artifactLockLayerAt' | 'convertStoredItem' | 'declinesStoredRow' | 'engine' | 'findPairAddedMemberRow' | 'findServedOverlayRow' | 'foldObjectExtendersFromRegistry' | 'governServedObject' | 'isArtifactBacked' | 'lookupArtifactItem' | 'overlayLockLayerAt' | 'packagelessReadAddress' | 'readItemActiveRows' | 'readItemFromMetadataService' | 'resolveRowlessExpandedView' | 'resolveWritePackageScope' | 'rethrowUnlessMetadataStoreUnprovisioned' | 'servedLockState' | 'strictDraftReadAddress' | 'throwMetadataServiceUnavailable'>, request: {
         type: string;
         name: string;
         packageId?: string;
         /** [#26699] The bundle member whose layers to read — {@link resolveBundleMemberSelector}; omitted, the canonical one. */
         member?: string;
-    }): Promise<{
+    }, opts: { withDraft?: boolean } = {}): Promise<{
         type: string;
         name: string;
         code: unknown | null;
         overlay: unknown | null;
         overlayScope: 'env' | null;
         effective: unknown | null;
+        /**
+         * [#29814] The pending draft row as stored — present only when the
+         * caller asked for it (`opts.withDraft`); `null` when no draft is
+         * pending. See the class method's docblock.
+         */
+        draft?: unknown | null;
         /**
          * Load-time validation result for the effective payload — same
          * shape attached to getMetaItems/getMetaItem by
@@ -418,6 +424,60 @@ export async function getMetaItemLayered(host: Pick<ProtocolHost, 'artifactLockL
         }
     }
 
+    // ── [#29814] The pending DRAFT layer, only when the caller asked ──
+    //
+    // The row the strict `state: 'draft'` read of {@link getMetaItem} serves,
+    // at the same address: the requested package's draft when one is named,
+    // else the draft {@link strictDraftReadAddress} names (the address the
+    // draft save, the per-item publish and the discard naming none act on),
+    // with that read's best-effort first match when two or more packages hold
+    // drafts and none is package-unbound. Read as the `overlay` layer is read:
+    // the stored body through the conversion chain and nothing else. ⛔ Not
+    // governed (no injected columns), not translated, no `_packageId` stamp:
+    // an edit buffer built from it and saved back writes what the author
+    // wrote. The strict read decorates and governs; this layer is the draft
+    // as stored, which is the whole reason it exists.
+    //
+    // Asked for by the DOOR, never by default: a door asks only for a caller
+    // its draft-read admission admits (`mayReadPendingDrafts`), so no
+    // in-process resolution reader of this method (the security catalog echo,
+    // the packaged-permission-set lock gate, `/published`) reads drafts.
+    let draft: unknown | null | undefined;
+    if (opts.withDraft === true) {
+        draft = null;
+        const draftAddress = request.packageId
+            ? undefined
+            : await host.strictDraftReadAddress(request.type, request.name, member);
+        try {
+            let draftRow = (await host.findServedOverlayRow({
+                type: request.type,
+                name: request.name,
+                state: 'draft',
+                ...(request.packageId
+                    ? { packageId: request.packageId }
+                    : draftAddress ? { packageId: draftAddress.packageId } : {}),
+                ...memberOption(member),
+            }))?.row;
+            if (!draftRow && draftAddress?.bestEffort) {
+                draftRow = (await host.findServedOverlayRow({
+                    type: request.type,
+                    name: request.name,
+                    state: 'draft',
+                    ...memberOption(member),
+                }))?.row;
+            }
+            if (draftRow) {
+                draft = host.convertStoredItem(
+                    String(draftRow.type ?? request.type),
+                    storedRowDocument(draftRow),
+                );
+            }
+        } catch (error) {
+            // [#5707] A read that did not happen is not "no draft pending".
+            host.rethrowUnlessMetadataStoreUnprovisioned(error, 'sys_metadata');
+        }
+    }
+
     // [#4513] `effective` is documented above as "what `getMetaItem` would
     // return", and the response's `_diagnostics` is computed from it — so it
     // carries the same audit-family governance that read now applies, or the
@@ -565,6 +625,9 @@ export async function getMetaItemLayered(host: Pick<ProtocolHost, 'artifactLockL
     const servedCode = redactMetadataItem(request.type, code);
     const servedOverlay = redactMetadataItem(request.type, overlay);
     const servedEffective = redactMetadataItem(request.type, effective);
+    // [#29814] …and the draft layer, by the same reasoning: redaction
+    // subtracts a credential and nothing else.
+    const servedDraft = draft === undefined ? undefined : redactMetadataItem(request.type, draft);
 
     return {
         type: request.type,
@@ -573,6 +636,7 @@ export async function getMetaItemLayered(host: Pick<ProtocolHost, 'artifactLockL
         overlay: servedOverlay,
         overlayScope,
         effective: servedEffective,
+        ...(servedDraft !== undefined ? { draft: servedDraft } : {}),
         ...(_diagnostics ? { _diagnostics } : {}),
         lock: lockState.lock,
         ...(lockState.lockReason !== undefined ? { lockReason: lockState.lockReason } : {}),
 
@@ -4613,20 +4613,34 @@ export class ObjectStackProtocolImplementation implements
      *         layer's MetadataService read reporting `degraded` with nothing
      *         in the registry to answer instead, carrying the failing loaders'
      *         messages on `cause`.
+     *
+     * [#29814] `opts.withDraft` adds the `draft` layer
+     * (`GetMetaItemLayeredResponseSchema.draft`): the pending draft row the
+     * strict `state: 'draft'` read of {@link getMetaItem} serves, at that
+     * read's address, AS STORED — converted like the `overlay` layer and
+     * credential-redacted like every layer, never governed, translated or
+     * stamped — or `null` when no draft is pending. Without the option the
+     * answer carries no `draft` key ("not served"). Only a door that has
+     * admitted its caller to pending drafts (`mayReadPendingDrafts` in
+     * `@objectstack/rest`, and its runtime twin) asks for it; every other
+     * reader of this method reads no draft. A failed draft read throws, as
+     * the overlay read does, for the same [#5707] reason.
      */
     async getMetaItemLayered(request: {
         type: string;
         name: string;
         packageId?: string;
         /** [#26699] The bundle member whose layers to read — {@link resolveBundleMemberSelector}; omitted, the canonical one. */
         member?: string;
-    }): Promise<{
+    }, opts: { withDraft?: boolean } = {}): Promise<{
         type: string;
         name: string;
         code: unknown | null;
         overlay: unknown | null;
         overlayScope: 'env' | null;
         effective: unknown | null;
+        /** [#29814] The pending draft row as stored, only when `opts.withDraft` asked; `null` for none. */
+        draft?: unknown | null;
         /**
          * Load-time validation result for the effective payload — same
          * shape attached to getMetaItems/getMetaItem by
@@ -4657,7 +4671,7 @@ export class ObjectStackProtocolImplementation implements
         resettable: boolean;
     }> {
         // [#25467 E1] The body moved to `protocol-meta-layered-reads.ts`; it reaches this class through `protocol-host.ts`.
-        return getMetaItemLayered(protocolHost(this), request);
+        return getMetaItemLayered(protocolHost(this), request, opts);
     }
 
     /**
 
@@ -18,7 +18,8 @@
  *
  * It walks the file's AST for every draft switch: a comparison against the
  * literal `'draft'`, a `.previewDrafts` read, and a `.listDrafts` reference.
- * Each is keyed `<route> » <text>` (the registration's `method` and `path`,
+ * [#29814] It also counts the layered read's `withDraft` option, keyed by its
+ * name. Each is keyed `<route> » <text>` (the registration's `method` and `path`,
  * else the named function around it — never a line number, this file is edited
  * several times a day) and must be LEDGERED below as one of:
  *
@@ -98,7 +99,9 @@ const isDraftSite = (n: ts.Node): boolean =>
     (ts.isBinaryExpression(n)
         && (n.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken || n.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken)
         && [n.left, n.right].some((side) => ts.isStringLiteral(side) && side.text === 'draft'))
-    || (ts.isPropertyAccessExpression(n) && ['previewDrafts', 'listDrafts'].includes(n.name.text));
+    || (ts.isPropertyAccessExpression(n) && ['previewDrafts', 'listDrafts'].includes(n.name.text))
+    // [#29814] The layered read's draft option, `{ withDraft: … }`, keyed by its name.
+    || (ts.isIdentifier(n) && n.text === 'withDraft' && ts.isPropertyAssignment(n.parent) && n.parent.name === n);
 
 const isAdmission = (n: ts.Node): boolean =>
     ts.isCallExpression(n) && n.expression.getText() === 'mayReadPendingDrafts';
@@ -186,6 +189,11 @@ const LEDGER: readonly LedgerRow[] = [
         disposition: 'write',
         door: 'DELETE /meta/:type/:name?state=draft — DISCARDS a draft; admitted by the write-capability gate first',
     },
+    {
+        site: 'method serveMetaItemLayered » withDraft',
+        disposition: 'read',
+        door: 'GET /meta/:type/:name/layers (and the deprecated ?layers=) — the pending draft layer',
+    },
     {
         site: 'POST ${basePath}/analytics/dataset/query » body.previewDrafts',
         disposition: 'read',
 
@@ -179,6 +179,8 @@ describe('#5882 GET /meta/:type/:name/layers — the declared layered resource',
         await dispatch(protocol, LAYERS_PATH, { type: 'object', name: 'customer' }, { package: 'com.acme.crm' });
         expect(protocol.getMetaItemLayered).toHaveBeenCalledWith(
             expect.objectContaining({ packageId: 'com.acme.crm' }),
+            // [#29814] The draft layer's option: this caller is not admitted to pending drafts.
+            { withDraft: false },
         );
     });
 
 
@@ -4147,11 +4147,20 @@ export function metaItemLayersDeprecationHeaders(
         : { Deprecation: 'true', Link: `<${itemPath}/layers>; rel="successor-version"` };
 }
 
-/** The layers a layered answer carries, in the order the gate judges them: `effective` first — it is what the plain read serves, so its refusal is the plain read's own. */
-const META_ITEM_LAYERS = ['effective', 'code', 'overlay'] as const;
+/**
+ * The layers a layered answer carries, in the order the gate judges them: `effective` first — it is what the plain read serves, so its refusal is the plain read's own.
+ * [#29814] `draft` last: the pending draft row as stored, present only when the transport admitted its caller to pending drafts and asked for it.
+ */
+const META_ITEM_LAYERS = ['effective', 'code', 'overlay', 'draft'] as const;
 
 /** The layers in the order the ADR-0106 mask projects them. */
-const META_ITEM_MASKED_LAYERS = ['code', 'overlay', 'effective'] as const;
+const META_ITEM_MASKED_LAYERS = ['code', 'overlay', 'effective', 'draft'] as const;
+
+/**
+ * [#29814] The layers an answer may leave out: absent means "not served", so the
+ * mask never writes the key in. The other three are always on the answer.
+ */
+const META_ITEM_OPTIONAL_LAYERS: ReadonlySet<string> = new Set(['draft']);
 
 /** The request facts the layered chain reads — no transport shape. */
 export interface MetaLayeredRequest {
@@ -4279,6 +4288,16 @@ export type MetaLayeredAnswer =
  *     through {@link projectMetaObjectSchema} under the posture resolved before
  *     the read, and the `private, no-store` an undetermined posture owes.
  *
+ * [#29814] `draft` — the pending draft row as stored
+ * (`GetMetaItemLayeredResponseSchema.draft`) — is a layer like the other three
+ * for every step above: it counts for step 1's presence (an admitted author's
+ * never-published item is its draft), the gate judges it under the same
+ * stored-version policy, and the mask projects it. It reaches this chain only
+ * when the transport asked the protocol for it, which each transport does only
+ * for a caller its draft-read admission (`mayReadPendingDrafts`) admits; for
+ * any other caller the answer carries no `draft` key, so it says nothing about
+ * whether a draft exists. The mask never writes an absent `draft` key in.
+ *
  * The protocol's answer is never mutated. A layer the gate or the mask leaves as
  * it was is served as it was, and every other key of the answer
  * (`overlayScope`, `_diagnostics`, the ADR-0010 protection envelope) rides
@@ -4330,10 +4349,13 @@ export function createMetaLayeredAnswer(
         // 3. [ADR-0106 D5(4)] The mask, on every layer — under one posture
         //    related [#21884] over every layer, so each object an `objectOverride`
         //    param names is asked about once.
-        const layerDocuments = META_ITEM_MASKED_LAYERS.map((layer) => (served.has(layer) ? served.get(layer) : layered?.[layer]));
+        const maskedLayers = META_ITEM_MASKED_LAYERS.filter(
+            (layer) => !META_ITEM_OPTIONAL_LAYERS.has(layer) || (layered != null && layer in layered),
+        );
+        const layerDocuments = maskedLayers.map((layer) => (served.has(layer) ? served.get(layer) : layered?.[layer]));
         const layerPosture = await relateObjectSchemaMaskPosture(maskPosture, ...layerDocuments);
         let cacheControl: typeof META_UNDETERMINED_CACHE_CONTROL | undefined;
-        for (const layer of META_ITEM_MASKED_LAYERS) {
+        for (const layer of maskedLayers) {
             const document = served.has(layer) ? served.get(layer) : layered?.[layer];
             const masked = projectMetaObjectSchema(layerPosture, document);
             if (!masked.ok) return { kind: 'mask-fault', object: name };
 
@@ -4352,7 +4352,15 @@ export class RestServer {
             ...metaReadGate.metaMemberSelector(req.query),
             ...(environmentId ? { environmentId } : {}),
         };
-        const layered = await p.getMetaItemLayered(layeredRequest);
+        // [#29814] The pending draft layer, asked for only when this caller may
+        // read pending drafts — the admission every draft switch in this file
+        // carries in its own declaration ({@link mayReadPendingDrafts}). A
+        // caller it does not admit is answered the layers without a `draft`
+        // key, byte-identical to a read that never asked for one, so the answer
+        // says nothing about whether a draft exists.
+        const layeredCaller = await this.resolveExecCtx(environmentId, req).catch(rethrowAuthzStoreUnavailable);
+        const layeredOptions = { withDraft: mayReadPendingDrafts(layeredCaller) };
+        const layered = await p.getMetaItemLayered(layeredRequest, layeredOptions);
         // [#20156 · #20478] THE per-caller gate on every layer, then the mask —
         // the shared chain. The stored-version doors honour the author
         // exemption, so the caller carries this transport's save-door