@@ -0,0 +1,10 @@
+---
+'@objectstack/metadata-protocol': patch
+---
+
+fix(metadata-protocol): the metadata list serves every stored `seed` item, named by its row
+
+Clause-②: no
+Metadata-protocol: none
+
+`getMetaItems({ type: 'seed' })`, the read behind `GET /api/v1/meta/seed`, listed no stored seed item while `GET /api/v1/meta/seed/:name` served each one. A seed body states no name (`SeedSchema` declares none; the name lives on the stored row), and the list merge keyed every stored body by its own `name`, so it skipped each seed. The merge now slots a stored body that states no name by its row's name, the name the by-name read finds it under, and serves it carrying that name. This holds on the environment's list, the package-scoped list and the draft preview, and a package's shipped seed of the same name shares that one slot. A body that states its own name keeps it, the stored body is not written, and `SeedSchema` is unchanged.
@@ -27,15 +27,15 @@ import {
     resolveItemLock,
     resolveOverlayLockLayer,
 } from './item-lock.js';
-import { decorateMetadataItems } from './metadata-diagnostics.js';
+import { decorateMetadataItem } from './metadata-diagnostics.js';
 import {
     isActionWithheldByDisabledPackage,
     isItemOfDisabledPackage,
 } from './protocol-authoring-refusals.js';
 import { soleShippingPackage } from './protocol-environment-rows.js';
 import type { ProtocolHost } from './protocol-host.js';
 import { canonicalizeMetaRequestType } from './protocol-meta-type-schema.js';
-import { mergePackageAwareOverlay, servedViewExpansion } from './protocol-overlay-merge.js';
+import { mergePackageAwareOverlay, servedViewExpansion, withoutServedRowName } from './protocol-overlay-merge.js';
 import {
     type ShippingPackages,
     boundPackageOf,
@@ -77,6 +77,20 @@ export async function getMetaItemsPerPackage(host: Pick<ProtocolHost, 'readFlatt
     return host.readFlattenedMetaItems(canonicalizeMetaRequestType(request), 'served', 'per-package');
 }
 
+/**
+ * [#31399] One listed item, decorated for the served face. An item the merge
+ * served its row's `name` (a body that states none, a `seed`) is judged as the
+ * row stores it, without that `name` its schema does not declare, which is the
+ * verdict the by-name read gives the same row; it is served with the name.
+ * Every other item is decorated as before ({@link decorateMetadataItem}).
+ */
+function decorateListedItem(type: string, item: unknown): unknown {
+    const stored = withoutServedRowName(item);
+    if (stored === undefined) return decorateMetadataItem(type, item);
+    const { _diagnostics, ...served } = decorateMetadataItem(type, stored);
+    return { ...served, name: (item as { name: string }).name, ...(_diagnostics !== undefined ? { _diagnostics } : {}) };
+}
+
 /** The body of `ObjectStackProtocolImplementation#readFlattenedMetaItems`; the method's docblock there is its contract. */
 export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactLockLayerAt' | 'baseServesBundleMember' | 'convertStoredItem' | 'declinesStoredRow' | 'disabledActionsOf' | 'engine' | 'environmentId' | 'expandStoredViewContainers' | 'findEnvironmentRows' | 'flowRegistrationsOf' | 'foldObjectExtendersFromRegistry' | 'getServicesRegistry' | 'governServedObject' | 'hydrateOverlayIntoRegistry' | 'isStoredEntryOfDeclinedName' | 'isUnservedSealedOverlay' | 'isWritablePackage' | 'lookupArtifactItem' | 'namesWithOwnStoredRow' | 'readActiveOverlayRows' | 'rethrowUnlessMetadataStoreUnprovisioned' | 'shippedArtifactsOf' | 'shippingPackagesOf' | 'shipsBundleName' | 'storedOverlayEntries'>, request: { type: string; packageId?: string; names?: readonly string[]; previewDrafts?: boolean },
         audience: 'served' | 'execution',
@@ -235,23 +249,25 @@ export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactL
             // spelling), so the merge picks a package's slot by the
             // served-row resolution the by-name read takes
             // ({@link servedOverlayRowCandidates}), not by row order.
-            const placed = mergeable.map(({ data, packageId: recPkg, type: recType }) => ({
-                data, packageId: recPkg, stored: { type: recType },
+            // [#31399] …and its row's `name`, which slots a body that states
+            // none ({@link mergePackageAwareOverlay}).
+            const placed = mergeable.map(({ name, data, packageId: recPkg, type: recType }) => ({
+                data, packageId: recPkg, stored: { type: recType, name },
             }));
             // [#21817] The package-less rows, placed the same way, as
             // stand-ins: the same parse and the same stored-row rule.
             const standIns = host.storedOverlayEntries(request, standInRows)
                 .filter((entry) => !host.declinesStoredRow(request.type, (entry.data as { name?: unknown } | null)?.name, storedEntryRow(entry)))
-                .map(({ data, type: recType }) => ({
-                    data, packageId: undefined, stored: { type: recType }, standIn: true,
+                .map(({ name, data, type: recType }) => ({
+                    data, packageId: undefined, stored: { type: recType, name }, standIn: true,
                 }));
             // [#28409] The pair's rows, placed the same way and bound to
             // the pair, as stand-ins: the merge serves one only where it
             // declares the override of the slot's package.
             const overrideStandIns = host.storedOverlayEntries(request, overrideRows)
                 .filter((entry) => !host.declinesStoredRow(request.type, (entry.data as { name?: unknown } | null)?.name, storedEntryRow(entry)))
-                .map(({ data, packageId: recPkg, type: recType }) => ({
-                    data, packageId: recPkg, stored: { type: recType }, standIn: true,
+                .map(({ name, data, packageId: recPkg, type: recType }) => ({
+                    data, packageId: recPkg, stored: { type: recType, name }, standIn: true,
                 }));
             items = mergePackageAwareOverlay(request.type, items, [...placed, ...standIns, ...overrideStandIns], (data, prev) => {
                 if (isView && data && typeof data === 'object') {
@@ -554,7 +570,11 @@ export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactL
                     // by-name read's preview arm serves, in any row order.
                     // [ADR-0131 D6/D7] Every row read here is the
                     // environment's (filtered at the read).
-                    const stored = { type: String(record.type ?? request.type) };
+                    // [#31399] …with its row's `name` (see the active arm).
+                    const stored = {
+                        type: String(record.type ?? request.type),
+                        ...(typeof record.name === 'string' ? { name: record.name } : {}),
+                    };
                     return { data, packageId: recPkg, stored };
                 };
                 const drafts = [
@@ -923,7 +943,9 @@ export async function readFlattenedMetaItems(host: Pick<ProtocolHost, 'artifactL
         type: request.type,
         // [#20552] Served: diagnostics + per-type credential redaction.
         // Execution: the stored bodies — see `getMetaItemsForExecution`.
-        items: audience === 'served' ? decorateMetadataItems(request.type, governed) : governed,
+        // [#31399] An item served its row's `name` (a body that states none)
+        // is judged as stored, without it, then served with it.
+        items: audience === 'served' ? governed.map((it) => decorateListedItem(request.type, it)) : governed,
         // [#23316] Served only: the engine's verdict on each listed flow —
         // see {@link flowRegistrationsOf}. The execution face is the
         // engine's own read, so it carries none.
 
@@ -82,6 +82,8 @@ export const OBJECT_EXTENSION_ITEM_SCHEMA = z.preprocess(withoutProtectionEnvelo
  * stored under (one extension per package per target). The body is not
  * given a `name`: a read serves it as it is stored, so what a GET answers
  * PUTs back through the strict schema. `undefined` = not addressable.
+ * [#31399] The list read's one exception, a body that states no name served
+ * with its row's, is stated at `SERVED_ROW_NAME` (`protocol-overlay-merge.ts`).
  */
 export function listSlotNameOf(canonicalType: string, item: unknown): unknown {
     if (!isRecord(item)) return undefined;
 
@@ -48,6 +48,39 @@ interface ServedOverlayRowCandidate {
  */
 interface StoredRowPlace {
     readonly type: string;
+    /**
+     * [#31399] The row's own `name` column: the name the by-name read finds
+     * the row under. The merge slots a stored body by it when the body states
+     * no name of its own ({@link mergePackageAwareOverlay}).
+     */
+    readonly name?: string;
+}
+
+/**
+ * [#31399] Marks a listed body that carries its row's `name` because it states
+ * none of its own ({@link mergePackageAwareOverlay}). A symbol key: object
+ * spreads along the list keep it, and it never reaches the wire. The list's
+ * served exit judges such a body's `_diagnostics` without that `name`
+ * ({@link withoutServedRowName}), since the document's schema does not
+ * declare it: the verdict is the one the by-name read gives the same row.
+ *
+ * ⚠️ The one exception to {@link listSlotNameOf}'s "the body is not given a
+ * `name`, so what a GET answers PUTs back through the strict schema": a body
+ * the list served its row's name (a `seed`; or any stored body that states no
+ * name, such as a legacy row saved before its schema declared one) carries a
+ * `name` the strict schema refuses, so a listed item PUT back verbatim is
+ * refused. The by-name read serves the body as stored, without it.
+ */
+export const SERVED_ROW_NAME: unique symbol = Symbol('metadata-protocol.servedRowName');
+
+/**
+ * [#31399] The body a listed item was stored as, when the list served it its
+ * row's `name` ({@link SERVED_ROW_NAME}); otherwise `undefined`.
+ */
+export function withoutServedRowName(item: unknown): Record<string, unknown> | undefined {
+    if (item === null || typeof item !== 'object' || (item as Record<PropertyKey, unknown>)[SERVED_ROW_NAME] !== true) return undefined;
+    const { name: _name, [SERVED_ROW_NAME]: _mark, ...stored } = item as Record<PropertyKey, unknown>;
+    return stored as Record<string, unknown>;
 }
 
 /**
@@ -357,8 +390,23 @@ export function mergePackageAwareOverlay(
         }
     }
     for (const { data, packageId, stored, standIn } of records) {
-        const body = data as any;
-        const bodyName = listSlotNameOf(canonicalType, body);
+        // [#31399] A stored body that states no name of its own (a `seed`:
+        // `SeedSchema` declares none, the name lives on the row) is slotted by
+        // its row's `name` column, the name the by-name read finds it under,
+        // and served carrying that name, as every listed item carries its own.
+        // Before, the merge skipped it, so `GET /meta/seed` listed no stored
+        // seed while `GET /meta/seed/:name` served each one. A body that states
+        // a name keeps it; the stored body is never written.
+        const ownName = listSlotNameOf(canonicalType, data);
+        const rowName = ownName === undefined && stored?.name !== undefined && stored.name !== ''
+            && data !== null && typeof data === 'object' && !Array.isArray(data)
+            ? stored.name
+            : undefined;
+        const body = (rowName !== undefined ? { ...(data as object), name: rowName, [SERVED_ROW_NAME]: true } : data) as any;
+        // A body whose own `name` is null still states one: it is listed under
+        // it (with `_diagnostics` flagging it), as before; only an absent name
+        // falls to the row's.
+        const bodyName = ownName !== undefined ? ownName : rowName;
         if (bodyName === undefined) continue;
         // The base row this record shadows at its own slot (for view-identity
         // healing): a same-package row, else a package-less one, else any