@@ -0,0 +1,11 @@
+---
+'@objectstack/objectql': patch
+---
+
+fix(objectql): a package registered again lists its navigation contributions once, not once more per registration
+
+Clause-②: no — the served app navigation returns to what a fresh boot serves; nothing a caller sends is refused
+Metadata-protocol: none
+
+- **Before.** Registering a package body appended its `navigationContributions` to the target app's list every time. An artifact reload (`metadata:reloaded`, fired when `os dev` recompiles the artifact or on the HMR reload POST) re-registers every package of the artifact, so after one reload the sidebar listed every module's contributed entries twice, three times after the next, until the server restarted. An uninstalled package's contributions also stayed in the app.
+- **Now.** A package body's contributions replace that package's previous set (`SchemaRegistry.setPackageNavContributions`, new), in the place its first registration put them, so the navigation after any number of reloads, re-registrations and disable/enable cycles equals a fresh boot's, in the same order. Uninstalling a package drops its contributions. `registerAppNavContribution` keeps its additive meaning.
@@ -2407,13 +2407,24 @@ export class ObjectQL implements IObjectQLEngine {
       // plugin adding its menu into the `setup` app). Merged into the target
       // app's navigation on read by group id + priority, so registration order
       // does not matter.
-      if (Array.isArray((manifest as any).navigationContributions) && (manifest as any).navigationContributions.length > 0) {
-          for (const contribution of (manifest as any).navigationContributions) {
+      // [#30581] A body with an id REPLACES its package's contributions, so a
+      // re-registration of the same body (an artifact reload re-registers every
+      // package of the artifact) folds each entry once, not once more per
+      // registration; a body that now declares none clears an earlier one's.
+      const navigationContributions: any[] = Array.isArray((manifest as any).navigationContributions)
+          ? (manifest as any).navigationContributions
+          : [];
+      if (id) {
+          this._registry.setPackageNavContributions(id, navigationContributions);
+      } else {
+          for (const contribution of navigationContributions) {
               this._registry.registerAppNavContribution(contribution, id);
           }
+      }
+      if (navigationContributions.length > 0) {
           this.logger.debug('Registered navigation contributions', {
               from: id,
-              count: (manifest as any).navigationContributions.length,
+              count: navigationContributions.length,
           });
       }
 
 
@@ -192,6 +192,10 @@ export function createRegistryModuleMock(
     // enable owes. The double never enables a disabled package, so it never
     // announces either.
     onPackageEnabled: vi.fn(() => () => {}),
+    // [#30581] Every `registerApp` of a body with an id hands its package's
+    // navigation contributions to this member (replace, never append). The
+    // double folds no navigation, so it records the call and nothing else.
+    setPackageNavContributions: vi.fn(),
     reset: vi.fn(),
     metadata: { get: vi.fn(() => new Map()) },
     ...instanceOverrides,
 
@@ -2,6 +2,7 @@
 
 import { describe, it, expect, beforeEach } from 'vitest';
 import { SchemaRegistry } from './registry';
+import { ObjectQL } from './engine';
 
 /**
  * ADR-0029 D7 — app navigation contributions.
@@ -104,3 +105,131 @@ describe('SchemaRegistry navigation contributions (ADR-0029 D7)', () => {
     expect(group.children).toHaveLength(1);
   });
 });
+
+/**
+ * [#30581] A package BODY's contributions are derived from its manifest, never
+ * appended to: registering the same body again folds each entry once.
+ *
+ * An artifact reload (`metadata:reloaded`) re-registers every package of the
+ * artifact through `ObjectQL.registerApp`, and the manifest step used to push
+ * each contribution once more per registration, so a single reload listed
+ * every module's entries twice until a restart. Each pin below compares the
+ * served app against the snapshot a fresh registration of the same bodies
+ * gives, in the same test.
+ */
+describe('[#30581] a package body re-registered folds its contributions once', () => {
+  const APP = 'com.qa.nav.app';
+  const ORDERS = 'com.qa.nav.orders';
+  const SERVICE = 'com.qa.nav.service';
+  const LOOSE = 'com.qa.nav.loose';
+
+  const appBody = () => ({
+    id: APP, name: APP, version: '1.0.0', type: 'app', namespace: 'qn',
+    apps: [{
+      name: 'qn_app', label: 'Suite',
+      navigation: [
+        { id: 'g_sales', type: 'group', label: 'Sales', children: [{ id: 'nav_accounts', type: 'object', label: 'Accounts', objectName: 'qn_account' }] },
+        { id: 'g_service', type: 'group', label: 'Service', children: [] },
+      ],
+    }],
+  });
+  // Equal priorities on purpose: the default 200 makes ties the common case,
+  // so the order a re-registration leaves is a real question.
+  const ordersBody = (items = [{ id: 'nav_orders', type: 'object', label: 'Orders', objectName: 'qn_order' }]) => ({
+    id: ORDERS, name: ORDERS, version: '1.0.0', type: 'module', namespace: 'qn', dependencies: { [APP]: '^1.0.0' },
+    navigationContributions: [
+      { app: 'qn_app', group: 'g_sales', items },
+      { app: 'qn_app', group: 'g_service', items: [{ id: 'nav_returns', type: 'object', label: 'Returns', objectName: 'qn_return' }] },
+    ],
+  });
+  const serviceBody = () => ({
+    id: SERVICE, name: SERVICE, version: '1.0.0', type: 'module', namespace: 'qn', dependencies: { [APP]: '^1.0.0' },
+    navigationContributions: [
+      { app: 'qn_app', group: 'g_service', items: [{ id: 'nav_cases', type: 'object', label: 'Cases', objectName: 'qn_case' }] },
+      { app: 'qn_app', group: 'g_sales', items: [{ id: 'nav_quotes', type: 'object', label: 'Quotes', objectName: 'qn_quote' }] },
+    ],
+  });
+  // A module that contributes nothing: toggling or re-registering it moves nothing.
+  const looseBody = () => ({ id: LOOSE, name: LOOSE, version: '1.0.0', type: 'module', namespace: 'qn', dependencies: { [APP]: '^1.0.0' } });
+
+  /** Every navigation entry of the served app, `group/id`, in served order. */
+  const served = (engine: ObjectQL): string[] =>
+    (engine.registry.getApp('qn_app')?.navigation ?? []).flatMap((n: any) =>
+      n.type === 'group' ? (n.children ?? []).map((c: any) => `${n.id}/${c.id}`) : [n.id]);
+
+  const boot = (): ObjectQL => {
+    const engine = new ObjectQL();
+    (engine.registry as any).logLevel = 'silent';
+    for (const body of [appBody(), ordersBody(), serviceBody(), looseBody()]) engine.registerApp(body as any);
+    return engine;
+  };
+
+  let engine: ObjectQL;
+  let fresh: string[];
+  beforeEach(() => {
+    engine = boot();
+    fresh = served(boot());
+  });
+
+  it('serves each entry once on a fresh registration (the control)', () => {
+    expect(fresh).toEqual([
+      'g_sales/nav_accounts', 'g_sales/nav_orders', 'g_sales/nav_quotes',
+      'g_service/nav_returns', 'g_service/nav_cases',
+    ]);
+    expect(served(engine)).toEqual(fresh);
+  });
+
+  it('re-registering every body twice (two artifact reloads) serves the fresh registration, in its order', () => {
+    for (let reload = 0; reload < 2; reload++) {
+      for (const body of [appBody(), ordersBody(), serviceBody(), looseBody()]) engine.registerApp(body as any);
+    }
+    expect(served(engine)).toEqual(fresh);
+    expect(engine.registry.getAppNavContributions('qn_app')).toHaveLength(4);
+  });
+
+  it('re-registering ONE module keeps its entries where a fresh registration puts them', () => {
+    engine.registerApp(ordersBody() as any);
+    engine.registerApp(ordersBody() as any);
+    expect(served(engine)).toEqual(fresh);
+  });
+
+  it('two disable/enable cycles of a module, each followed by a reload, serve the fresh registration', () => {
+    // The enable announcement the roll-up recompute rides on (#30377) still
+    // fires once per enable of a disabled package: a reload is no enable.
+    const heard: string[] = [];
+    const stop = engine.registry.onPackageEnabled((id) => { heard.push(id); });
+    for (let cycle = 0; cycle < 2; cycle++) {
+      engine.registry.disablePackage(ORDERS);
+      expect(served(engine)).toEqual(['g_sales/nav_accounts', 'g_sales/nav_quotes', 'g_service/nav_cases']);
+      for (const body of [appBody(), ordersBody(), serviceBody(), looseBody()]) engine.registerApp(body as any);
+      engine.registry.enablePackage(ORDERS);
+      expect(served(engine)).toEqual(fresh);
+    }
+    stop();
+    expect(heard).toEqual([ORDERS, ORDERS]);
+  });
+
+  it('toggling and re-registering a module with no contributions leaves the navigation unchanged', () => {
+    engine.registry.disablePackage(LOOSE);
+    engine.registerApp(looseBody() as any);
+    engine.registry.enablePackage(LOOSE);
+    expect(served(engine)).toEqual(fresh);
+  });
+
+  it('a re-registered body replaces its contributions: an entry it dropped leaves, one it added appears once', () => {
+    engine.registerApp(ordersBody([{ id: 'nav_invoices', type: 'object', label: 'Invoices', objectName: 'qn_invoice' }]) as any);
+    expect(served(engine)).toEqual([
+      'g_sales/nav_accounts', 'g_sales/nav_invoices', 'g_sales/nav_quotes',
+      'g_service/nav_returns', 'g_service/nav_cases',
+    ]);
+    const { navigationContributions: _dropped, ...withNone } = ordersBody();
+    engine.registerApp(withNone as any);
+    expect(served(engine)).toEqual(['g_sales/nav_accounts', 'g_sales/nav_quotes', 'g_service/nav_cases']);
+  });
+
+  it('uninstalling a module (not disabling it) drops its contributions from the app', () => {
+    expect(engine.registry.uninstallPackage(ORDERS), 'precondition: uninstalled').toBe(true);
+    expect(served(engine)).toEqual(['g_sales/nav_accounts', 'g_sales/nav_quotes', 'g_service/nav_cases']);
+    expect(engine.registry.getAppNavContributions('qn_app').map((c) => c.packageId)).toEqual([SERVICE, SERVICE]);
+  });
+});
@@ -8456,6 +8456,9 @@ export class SchemaRegistry {
     // …and the default record pages it declared, so the next package may
     // declare a default for those objects.
     this.forgetDefaultRecordPageClaims(id);
+    // [#30581] …and the navigation entries it put into other packages' apps:
+    // with no row left, the fold's disabled check cannot withhold them.
+    this.setPackageNavContributions(id, []);
 
     // [#18877] The boot seed forgets the id together with the row. A package
     // that no longer exists has no lifecycle state to preserve, so the next
@@ -8616,6 +8619,60 @@ export class SchemaRegistry {
     );
   }
 
+  /**
+   * [#30581] Make `contributions` the WHOLE set of navigation contributions
+   * `packageId` holds, in every app: what the package registered before is
+   * replaced, never added to. The door a package BODY takes (`registerApp`'s
+   * manifest step), so registering the same body again (an artifact reload,
+   * whose `metadata:reloaded` re-registers every package of the artifact, a
+   * manifest replay, an upgrade) leaves each entry once, instead of one more
+   * copy of every module's entries per registration until a restart.
+   *
+   * Replaced IN PLACE: an app's list keeps the package's entries where its
+   * first registration put them, so the fold's ties (equal priority, the
+   * common case at the default 200) resolve in the order a fresh boot gives.
+   * An app the package newly contributes to gets them at the end; an app it no
+   * longer names loses them. {@link registerAppNavContribution} stays the
+   * additive verb, for a caller adding one contribution at a time.
+   */
+  setPackageNavContributions(
+    packageId: string,
+    contributions: ReadonlyArray<{ app: string; group?: string; priority?: number; items?: any[] }>,
+  ): void {
+    const incoming = new Map<string, Array<{ packageId?: string; group?: string; priority: number; items: any[] }>>();
+    for (const contribution of contributions) {
+      if (!contribution || !contribution.app) continue;
+      const list = incoming.get(contribution.app) ?? [];
+      list.push({
+        packageId,
+        group: contribution.group,
+        priority: contribution.priority ?? 200,
+        items: Array.isArray(contribution.items) ? contribution.items : [],
+      });
+      incoming.set(contribution.app, list);
+    }
+    for (const [app, list] of [...this.appNavContributions]) {
+      const at = list.findIndex((c) => c.packageId === packageId);
+      if (at === -1) continue;
+      const kept = list.filter((c) => c.packageId !== packageId);
+      kept.splice(at, 0, ...(incoming.get(app) ?? []));
+      incoming.delete(app);
+      if (kept.length > 0) this.appNavContributions.set(app, kept);
+      else this.appNavContributions.delete(app);
+    }
+    for (const [app, list] of incoming) {
+      this.appNavContributions.set(app, [...(this.appNavContributions.get(app) ?? []), ...list]);
+    }
+    for (const c of contributions) {
+      if (!c || !c.app) continue;
+      this.log(
+        `[Registry] Navigation contribution: ${packageId} -> ${c.app}` +
+          (c.group ? `/${c.group}` : '') +
+          ` (${Array.isArray(c.items) ? c.items.length : 0} items)`,
+      );
+    }
+  }
+
   /** Contributions registered for an app (empty array when none). */
   getAppNavContributions(appName: string): Array<{ packageId?: string; group?: string; priority: number; items: any[] }> {
     return this.appNavContributions.get(appName) ?? [];
 
@@ -149,6 +149,9 @@ interface Booted {
     engine: ObjectQL;
 }
 
+/** [#30581] The host plugin's context of the last boot, to fire the kernel event an artifact reload fires. */
+let lastHostContext: PluginContext | undefined;
+
 /**
  * One kernel, the suite arriving by `path`:
  *  - `code`: the suite is the `AppPlugin`'s bundle, registered through the
@@ -174,6 +177,7 @@ async function bootKernel(path: InstallPath, root: string): Promise<Booted> {
         name: 'qa.suite-host',
         dependencies: ['com.objectstack.engine.objectql'],
         init: async (ctx: PluginContext) => {
+            lastHostContext = ctx;
             const door = ctx.getService<ManifestDoor>('manifest');
             if (path === 'marketplace') await door.register(suiteArtifact(), { source: 'marketplace' });
             for (const manifest of STANDALONE) await door.register(manifest);
@@ -369,6 +373,47 @@ describe('[#28117] a disabled module stays disabled across a restart (the enviro
     }, 120_000);
 });
 
+describe('[#30581] a module disabled and enabled again, around artifact reloads, lists its nav entries once', () => {
+    let root: string;
+    let booted: Booted | undefined;
+    let context: PluginContext;
+
+    beforeAll(async () => {
+        root = mkdtempSync(join(tmpdir(), 'os-suite-reload-'));
+        process.env.OS_HOME = mkdtempSync(join(home, 'reload-'));
+        booted = await bootKernel('code', root);
+        context = lastHostContext!;
+    }, 60_000);
+    afterAll(async () => {
+        await shutdown(booted);
+        rmSync(root, { recursive: true, force: true });
+    }, 60_000);
+
+    // What `MetadataPlugin` fires when it reloads the artifact (`os dev` recompiling
+    // `dist/objectstack.json`, the HMR POST): `ObjectQLPlugin` re-registers every
+    // package of it through `registerApp`, the step that used to append each
+    // contribution once more per reload.
+    const reloadArtifact = () => context.trigger('metadata:reloaded', { changed: ['dist/objectstack.json'], metadata: suiteArtifact() });
+
+    it('serves the fresh boot\'s navigation after two disable/enable cycles, each with a reload, and after a manifest replay', async () => {
+        const kernel = booted!.kernel;
+        const fresh = await servedGroupIds(kernel);
+        expect(fresh, 'precondition: the fresh boot lists each entry once').toEqual(['nav_accounts', 'nav_orders']);
+
+        for (let cycle = 1; cycle <= 2; cycle++) {
+            expect((await dispatchAs(kernel, 'PATCH', `/packages/${MODULE}/disable`)).status, `disable #${cycle}`).toBe(200);
+            await reloadArtifact();
+            expect(await servedGroupIds(kernel), `disabled, after reload #${cycle}`).toEqual(['nav_accounts']);
+            expect((await dispatchAs(kernel, 'PATCH', `/packages/${MODULE}/enable`)).status, `enable #${cycle}`).toBe(200);
+            expect(await servedGroupIds(kernel), `enabled again #${cycle}`).toEqual(fresh);
+            expect(registryGroupIds(booted!.engine)).toEqual(fresh);
+        }
+
+        await kernel.getService<ManifestDoor>('manifest').register(suiteArtifact());
+        expect(await servedGroupIds(kernel), 'after the suite is registered again through the manifest door').toEqual(fresh);
+    });
+});
+
 describe('[#28117 addendum 6523684730] what an app hook meets reading a disabled module\'s object through ctx.api.object()', () => {
     let root: string;
     let booted: Booted | undefined;