@@ -373,24 +373,49 @@ describe('publishMetaItem — the per-item door names a package too (#10350)', (
         expect(labelOf(drafts[0])).toBe('FROM_OTHER');
     });
 
-    it('keeps the historical match-any resolution when the caller states NO package', async () => {
+    // [#23495] Replaced, not respelled: this case pinned the absent key's
+    // "match any package" resolution, which promoted this fixture's
+    // first-scanned draft (`app.other`) — the storage-order coin toss #8907
+    // removed from the batch door, on the per-item door. Naming no package,
+    // the publish now promotes the draft a draft save naming no package
+    // writes, and this item (no active row, two packages' drafts, no
+    // package-less draft) has no single one. What the case also guarded stays
+    // pinned: the absent key is not a present `null`, which would pin the
+    // lookup to the unbound row and answer `no_draft` (the next case).
+    it('refuses 409 RESOURCE_CONFLICT when the caller states NO package and two packages hold drafts, promoting nothing', async () => {
         const { engine, rows } = makeStubEngine();
         const protocol = new ObjectStackProtocolImplementation(engine);
 
         await seedTwoPackageDrafts(protocol);
 
+        const refusal = await protocol.publishMetaItem({ type: 'object', name: 'shared_ticket' })
+            .then(() => undefined, (e: any) => e);
+
+        expect(refusal).toMatchObject({ code: 'RESOURCE_CONFLICT', status: 409 });
+        expect(refusal.message).toContain("'app.demo'");
+        expect(refusal.message).toContain("'app.other'");
+        expect(activeRowsOf(rows)).toEqual([]);
+        expect(draftRowsOf(rows).map((r) => r.package_id)).toEqual(['app.other', 'app.demo']);
+    });
+
+    it('promotes the one package\'s draft when the caller states NO package — the absent key is not a present `null`', async () => {
+        const { engine, rows } = makeStubEngine();
+        const protocol = new ObjectStackProtocolImplementation(engine);
+
+        await protocol.saveMetaItem({
+            type: 'object',
+            name: 'shared_ticket',
+            item: objectBody('shared_ticket', 'FROM_OTHER'),
+            packageId: 'app.other',
+            mode: 'draft',
+        });
+
         await protocol.publishMetaItem({ type: 'object', name: 'shared_ticket' });
 
-        // The contract `promoteDraftForPublish` spells as
-        // `...('packageId' in request ? ... : {})`: an ABSENT key means "match
-        // any package" (this fixture's first-scanned row), while a
-        // present-and-`undefined` key would coerce to `null` downstream and pin
-        // the lookup to UNBOUND rows — finding neither draft and answering
-        // `no_draft`. Declaring `packageId` optional must not turn the first
-        // spelling into the second, so the untouched path is pinned here.
         const active = activeRowsOf(rows);
         expect(active).toHaveLength(1);
         expect(active[0].package_id).toBe('app.other');
         expect(labelOf(active[0])).toBe('FROM_OTHER');
+        expect(draftRowsOf(rows)).toEqual([]);
     });
 });
@@ -523,9 +523,9 @@ describe('a publish promotes only the draft its gate judged', () => {
 
 // The lock a publish consults is the one at the address it promotes: the
 // package key the publish resolved (the caller's stated binding, else the
-// draft row's own), not only the package the request stated. With two
-// packages' env-wide rows of one view both locked, the refusal carries the
-// lock of the package whose draft is being promoted.
+// draft address it resolves), not only the package the request stated. With
+// two packages' env-wide rows of one view both locked, the refusal of a
+// publish naming its package carries that package's lock.
 describe('a publish consults the lock of the package key it resolved', () => {
     const locked = (pkg: string) => ({ ...VIEW, _lock: 'full', _lockReason: `${pkg} keeps this view as shipped` });
 
@@ -543,10 +543,20 @@ describe('a publish consults the lock of the package key it resolved', () => {
         return { protocol, draftsOf };
     }
 
-    it('a publish that states no package consults the lock of the draft row\'s own package', async () => {
+    // [#23495] Replaced, not respelled: this case pinned a publish naming no
+    // package consulting the lock of the draft row a package-agnostic read met
+    // (`pkg_b`), over an item whose active rows two packages hold. Naming no
+    // package, the publish now takes the draft save's address, and an item two
+    // packages hold has none: the publish is judged by the lock the draft save
+    // naming no package is judged by, and answers what that save answers.
+    it('a publish that states no package, of an item two packages hold, is judged by the lock the draft save naming none is', async () => {
         const { protocol, draftsOf } = await seedLockedRowsAndDraft('pkg_b');
+        const saveRefusal = await protocol.saveMetaItem({
+            type: 'view', name: VIEW.name, item: { ...VIEW, label: 'Org grid (edited)' }, mode: 'draft',
+        }).then(() => undefined, (e: any) => e);
+        expect(saveRefusal).toMatchObject({ code: 'ITEM_LOCKED', status: 403, lock: 'full' });
         await expect(protocol.publishMetaItem({ type: 'view', name: VIEW.name }))
-            .rejects.toMatchObject({ code: 'ITEM_LOCKED', status: 403, lock: 'full', lockReason: 'pkg_b keeps this view as shipped' });
+            .rejects.toMatchObject({ code: 'ITEM_LOCKED', status: 403, lock: 'full', lockReason: saveRefusal.lockReason });
         expect(draftsOf()).toEqual(['pkg_b']);
     });