@vc-shell/framework 1.2.3 → 1.2.4-beta.2

package/core/plugins/modularity/index.ts

@@ -1,13 +1,15 @@
-import { App, Component, h, inject, resolveComponent, watch } from "vue";
+import { App, Component, inject, resolveComponent } from "vue";
 import { i18n } from "./../i18n";
 import { Router } from "vue-router";
-import { BladeInstanceConstructor, BladeVNode } from "./../../../shared/components/blade-navigation/types";
-import { kebabToPascal } from "./../../utilities";
+import { BladeInstanceConstructor } from "./../../../shared/components/blade-navigation/types";
+import { kebabToPascal, createLogger } from "./../../utilities";
 import { addMenuItem, useMenuService, useNotifications } from "../../composables";
 import * as _ from "lodash-es";
-import { notification } from "../../../shared";
+import { notification } from "../../../shared/components/notifications/core";
 import { BladeRegistryKey, IBladeRegistrationData, IBladeRegistryInstance } from "../../composables/useBladeRegistry";
 
+const logger = createLogger("modularity");
+
 export function createModule(components: { [key: string]: BladeInstanceConstructor }, locales?: unknown) {
   return {
     install(app: App): void {
@@ -17,7 +19,7 @@ export function createModule(components: { [key: string]: BladeInstanceConstruct
         if (app.component(componentName)) {
           // Remove the existing component
           // Note: Vue does not provide a method to remove a component, so we can overwrite it
-          console.warn(
+          logger.warn(
             `Component ${componentName} is already registered. It will be overwritten with the new component.`,
           );
         }
@@ -35,36 +37,62 @@ export function createModule(components: { [key: string]: BladeInstanceConstruct
   };
 }
 
+/**
+ * Options for createAppModule.
+ */
+export interface AppModuleOptions {
+  /**
+   * List of blade names that must already be registered before this module installs.
+   * Used to enforce load-order dependencies between modules.
+   *
+   * @example
+   * ```ts
+   * export default createAppModule(pages, locales, undefined, undefined, {
+   *   dependsOn: ["SellerDetails", "Products"],
+   * });
+   * ```
+   */
+  dependsOn?: string[];
+}
+
 export function createAppModule(
   pages: { [key: string]: BladeInstanceConstructor },
   locales?: { [key: string]: object },
   notificationTemplates?: { [key: string]: Component & { notifyType?: string } },
   moduleComponents?: { [key: string]: Component },
+  moduleOptions?: AppModuleOptions,
 ) {
   return {
     install(app: App, options?: { router: Router }): void {
-      let routerInstance: Router;
-
       // Inject the BladeRegistry instance
       const bladeRegistry = app.runWithContext(() => inject<IBladeRegistryInstance>(BladeRegistryKey));
       let registerBladeWithRegistry: (name: string, data: IBladeRegistrationData) => void;
 
+      // Validate module dependencies (must be registered before this module)
+      if (moduleOptions?.dependsOn?.length && bladeRegistry) {
+        const missing = moduleOptions.dependsOn.filter(
+          (dep) => !bladeRegistry.getBlade(dep),
+        );
+        if (missing.length > 0) {
+          const moduleName = Object.values(pages)[0]?.name || "unknown";
+          logger.error(
+            `Module '${moduleName}' depends on blades [${missing.join(", ")}] ` +
+            `which are not yet registered. Ensure dependent modules are installed first.`,
+          );
+        }
+      }
+
       if (bladeRegistry && bladeRegistry._registerBladeFn) {
         registerBladeWithRegistry = bladeRegistry._registerBladeFn;
       } else {
-        console.error(
+        logger.error(
           "createAppModule: BladeRegistry or its _registerBladeFn not found via inject. Blade registration will be skipped.",
         );
         registerBladeWithRegistry = (name: string, data: IBladeRegistrationData) => {
-          console.warn(`BladeRegistry (noop): Tried to register '${name}' but _registerBladeFn is missing.`);
+          logger.warn(`BladeRegistry (noop): Tried to register '${name}' but _registerBladeFn is missing.`);
         };
       }
 
-      if (options && options.router) {
-        const { router } = options;
-        routerInstance = router;
-      }
-
       const uid = _.uniqueId("module_");
 
       // Register pages
@@ -83,7 +111,7 @@ export function createAppModule(
               isWorkspace: page.isWorkspace || false,
             });
           } else {
-            console.warn(
+            logger.warn(
               "createAppModule: Page without URL is missing a name. Cannot register with BladeRegistry.",
               page,
             );
@@ -98,30 +126,11 @@ export function createAppModule(
             component: page,
             route: page.url,
             isWorkspace: page.isWorkspace || false,
+            routable: page.routable !== false,
           });
 
-          const mainRoute = routerInstance.getRoutes().find((r) => r.meta?.root);
-          if (!mainRoute) {
-            throw new Error("Main route not found. Make sure you have added `meta: {root: true}` to the main route.");
-          }
-          const mainRouteName = mainRoute.name;
-
-          const bladeVNodeForRouter = h(page, {
-            navigation: {},
-          }) as BladeVNode;
-
-          if (routerInstance.hasRoute(routeName)) {
-            routerInstance.removeRoute(routeName);
-          }
-
-          routerInstance.addRoute(mainRouteName as string, {
-            name: routeName,
-            path: page.url.substring(1),
-            components: { default: bladeVNodeForRouter },
-            meta: {
-              permissions: page.permissions,
-            },
-          });
+          // Note: No router.addRoute() — blades are NOT Vue Router pages.
+          // BladeStack manages blade rendering; Vue Router is URL sync only.
 
           if (page.menuItem) {
             addMenuItem({
@@ -179,7 +188,8 @@ export function createAppModule(
           // Check if the component is already registered
           if (app.component(name)) {
             // Overwrite existing component
-            console.warn(`Component ${name} is already registered. It will be overwritten with the new component.`);
+            logger.warn(`Component ${name} is already registered. It will be overwritten with the new component.`);
+            logger.warn(`Component ${name} is already registered. It will be overwritten with the new component.`);
           }
           app.component(name, component);
         });

package/core/plugins/modularity/loader.ts

@@ -2,7 +2,10 @@ import { App, Plugin } from "vue";
 import { Router } from "vue-router";
 import { DynamicModulesKey } from "../../../injection-keys";
 import * as semver from "semver";
-import { notification } from "../../../shared";
+import { notification } from "../../../shared/components/notifications/core";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("module-loader");
 
 interface ModuleManifest {
   file: string;
@@ -108,12 +111,12 @@ async function loadVersionInfo(url: string): Promise<VersionInfo | null> {
   try {
     const response = await fetch(url);
     if (!response.ok) {
-      console.warn(`Failed to load version info: ${response.statusText}`);
+      logger.warn(`Failed to load version info: ${response.statusText}`);
       return null;
     }
     return (await response.json()) as VersionInfo;
   } catch (error) {
-    console.warn(`Error loading version info: ${error}`);
+    logger.warn(`Error loading version info: ${error}`);
     return null;
   }
 }
@@ -145,7 +148,7 @@ function checkVersionCompatibility(
     moduleVersion.compatibleWith.framework &&
     !semver.satisfies(frameworkVersion, moduleVersion.compatibleWith.framework, { includePrerelease: true })
   ) {
-    console.error(
+    logger.error(
       `Module ${moduleId} requires framework version ${moduleVersion.compatibleWith.framework}, but current framework version is ${frameworkVersion}.`,
     );
     notification.error(
@@ -163,12 +166,12 @@ function checkVersionCompatibility(
       const loadedDepVersion = loadedModulesWithVersions.get(depModuleId);
 
       if (!loadedDepVersion) {
-        console.warn(`Module ${moduleId} depends on ${depModuleId}, but it is not loaded yet.`);
+        logger.warn(`Module ${moduleId} depends on ${depModuleId}, but it is not loaded yet.`);
         continue;
       }
 
       if (!semver.satisfies(loadedDepVersion, versionRange, { includePrerelease: true })) {
-        console.error(
+        logger.error(
           `Module ${moduleId} requires ${depModuleId} version ${versionRange}, but loaded version is ${loadedDepVersion}.`,
         );
         notification.error(
@@ -233,7 +236,7 @@ export function useDynamicModules(
   const finalConfig = { ...DEFAULT_CONFIG, ...config };
 
   if (!config.frameworkVersion && finalConfig.frameworkVersion) {
-    console.warn(
+    logger.warn(
       `Framework version not specified in the configuration, using default ${finalConfig.frameworkVersion}. This may cause compatibility issues with modules.`,
     );
   }
@@ -272,7 +275,7 @@ export function useDynamicModules(
               manifest: (await response.json()) as Manifest,
             };
           } catch (error) {
-            console.error(error);
+            logger.error("Error loading module manifest:", error);
             return null;
           }
         });
@@ -303,12 +306,12 @@ export function useDynamicModules(
                   .filter((file) => file.file.endsWith(".css"))
                   .map((file) => loadCSS(moduleUrl + file.file)),
               ).catch((error) => {
-                console.error(`Failed to load styles for module ${moduleId}:`, error);
+                logger.error(`Failed to load styles for module ${moduleId}:`, error);
               }),
             ]);
 
             if (versionInfoFromFile) {
-              console.info(`Loaded version info for module ${moduleId}: v${versionInfoFromFile.version}`);
+              logger.info(`Loaded version info for module ${moduleId}: v${versionInfoFromFile.version}`);
             }
 
             // Import module
@@ -322,7 +325,7 @@ export function useDynamicModules(
               success: true,
             };
           } catch (error) {
-            console.error(`Failed to load module ${moduleId}:`, error);
+            logger.error(`Failed to load module ${moduleId}:`, error);
             return {
               moduleId,
               moduleUrl,
@@ -342,7 +345,7 @@ export function useDynamicModules(
           moduleLoadResults.filter((result) => result.success).map((result) => [result.moduleId, result]),
         );
 
-        console.log("🔍 LoadResultsMap keys:", Array.from(loadResultsMap.keys()));
+        logger.debug("LoadResultsMap keys:", Array.from(loadResultsMap.keys()));
 
         // Wait for all modules to register themselves in the global scope
         const expectedModuleIds = Array.from(loadResultsMap.keys());
@@ -369,9 +372,9 @@ export function useDynamicModules(
 
         // Check if modules are already registered
         if (areAllModulesRegistered()) {
-          console.log("✅ All modules are already registered, proceeding with installation");
+          logger.debug("All modules are already registered, proceeding with installation");
         } else {
-          console.log(`🔍 Waiting for ${expectedModuleIds.length} modules to register:`, expectedModuleIds);
+          logger.debug(`Waiting for ${expectedModuleIds.length} modules to register:`, expectedModuleIds);
 
           // Wait for module registration with timeout
           await new Promise<void>((resolve) => {
@@ -392,7 +395,7 @@ export function useDynamicModules(
 
             const checkAndResolve = () => {
               if (areAllModulesRegistered()) {
-                console.log("✅ All modules are registered, proceeding with installation");
+                logger.debug("All modules are registered, proceeding with installation");
                 cleanup();
                 resolve();
                 return true;
@@ -410,8 +413,8 @@ export function useDynamicModules(
             const poll = async () => {
               while (attempts < maxAttempts) {
                 const availableModules = getAvailableModules();
-                console.log(
-                  `🔍 Attempt ${attempts + 1}: Available modules:`,
+                logger.debug(
+                  `Attempt ${attempts + 1}: Available modules:`,
                   availableModules,
                   `(${availableModules.length}/${expectedModuleIds.length})`,
                 );
@@ -422,7 +425,7 @@ export function useDynamicModules(
                 await new Promise((r) => setTimeout(r, 100));
               }
 
-              console.warn("⚠️ Timeout waiting for all modules to register, proceeding with available modules");
+              logger.warn("Timeout waiting for all modules to register, proceeding with available modules");
               cleanup();
               resolve();
             };
@@ -441,18 +444,18 @@ export function useDynamicModules(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const modulesToProcess: [string, any][] = Object.entries(window.VcShellDynamicModules || {});
 
-        console.log(
-          `🚀 Found ${modulesToProcess.length} modules to process:`,
+        logger.debug(
+          `Found ${modulesToProcess.length} modules to process:`,
           modulesToProcess.map(([name]) => name),
         );
 
         for (const [moduleName, moduleObject] of modulesToProcess) {
           if (loadedModules.has(moduleName)) {
-            console.log(`⏭️ Skipping already loaded module: ${moduleName}`);
+            logger.debug(`Skipping already loaded module: ${moduleName}`);
             continue;
           }
 
-          console.log(`📦 Processing module: ${moduleName}`);
+          logger.debug(`Processing module: ${moduleName}`);
 
           // Try to find the corresponding load result by matching module names
           const loadResult =
@@ -469,16 +472,16 @@ export function useDynamicModules(
 
           const mainModule = getModuleInstall(moduleObject);
 
-          console.log(`🔍 Module ${moduleName} exports:`, Object.keys(moduleObject));
-          console.log(`🔍 Module ${moduleName} has install function:`, !!mainModule);
+          logger.debug(`Module ${moduleName} exports:`, Object.keys(moduleObject));
+          logger.debug(`Module ${moduleName} has install function:`, !!mainModule);
 
           if (mainModule) {
             const moduleVersionInfo = (mainModule as ModuleWithNamedExport).version || versionFromFile;
 
             try {
               if (!finalConfig.skipVersionCheck) {
-                console.log(
-                  `🔎 Checking compatibility for ${moduleName} (version: ${moduleVersionInfo?.version || "N/A"})`,
+                logger.debug(
+                  `Checking compatibility for ${moduleName} (version: ${moduleVersionInfo?.version || "N/A"})`,
                 );
                 checkVersionCompatibility(
                   moduleName,
@@ -488,7 +491,7 @@ export function useDynamicModules(
                 );
               }
 
-              console.log(`🔧 Installing module: ${moduleName}`, {
+              logger.debug(`Installing module: ${moduleName}`, {
                 hasLoadResult: !!loadResult,
                 versionFromFile: versionFromFile?.version,
                 moduleVersion: moduleVersionInfo?.version,
@@ -503,31 +506,31 @@ export function useDynamicModules(
                 loadedModulesWithVersions.set(moduleName, moduleVersionInfo.version);
               }
 
-              console.log(
-                `✅ Module ${moduleName} installed successfully (version: ${
+              logger.info(
+                `Module ${moduleName} installed successfully (version: ${
                   moduleVersionInfo?.version || "no version info"
                 })`,
               );
             } catch (e) {
               if (e instanceof VersionCompatibilityError) {
-                console.error(`Compatibility error in module ${e.moduleId}:`, e.details);
+                logger.error(`Compatibility error in module ${e.moduleId}:`, e.details);
               } else {
-                console.error(`Failed to install module ${moduleName}:`, e);
+                logger.error(`Failed to install module ${moduleName}:`, e);
                 notification.error(`Failed to install module ${moduleName}`);
               }
             }
           } else {
-            console.error(`❌ Module ${moduleName} does not have an 'install' function`);
+            logger.error(`Module ${moduleName} does not have an 'install' function`);
             notification.error(
               `Module ${moduleName} is not a valid module because it does not have an 'install' function.`,
             );
           }
         }
 
-        console.log("🏁 Final loadedModules set:", Array.from(loadedModules));
+        logger.debug("Final loadedModules set:", Array.from(loadedModules));
       }
     } catch (error) {
-      console.error("Failed to load modules:", error);
+      logger.error("Failed to load modules:", error);
     }
 
     app.config.globalProperties.$dynamicModules = {

package/core/plugins/signalR/index.ts

@@ -4,6 +4,9 @@ import { PushNotification } from "../../api/platform";
 import { useNotifications } from "./../../composables/useNotifications";
 import { useUserManagement } from "../../composables/useUserManagement";
 import { useCypressSignalRMock } from "cypress-signalr-mock";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("signalR");
 
 const { addNotification } = useNotifications();
 const currentCreator = ref<string | undefined>();
@@ -17,7 +20,7 @@ function setupSystemEventsHandler(connection: any, creator?: string) {
 
   // Subscribe to events with the new creator
   if (creator) {
-    console.log("[SignalR] Setup handler for creator: ", creator);
+    logger.debug("Setup handler for creator: ", creator);
     connection.on("SendSystemEvents", (message: PushNotification) => {
       if (message.creator === creator) {
         addNotification(message);
@@ -48,11 +51,11 @@ export const signalR = {
       connection
         .start()
         .then(() => {
-          console.log("[SignalR] Connected.");
+          logger.info("Connected.");
           setupSystemEventsHandler(connection, currentCreator.value);
         })
         .catch((err) => {
-          console.log("[SignalR] Connection Error: ", err);
+          logger.error("Connection Error: ", err);
           setTimeout(() => start(), 5000);
         });
     };

package/core/services/_internal/createBladeScopedRegistry.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createBladeScopedRegistry, type BladeScopedRegistry } from "./createBladeScopedRegistry";
+
+interface TestItem {
+  id: string;
+  bladeId?: string;
+  label?: string;
+}
+
+interface TestRegistration {
+  bladeId: string;
+  item: TestItem;
+}
+
+function createTestRegistry(): BladeScopedRegistry<TestItem, TestRegistration> {
+  return createBladeScopedRegistry<TestItem, TestRegistration>({
+    createRegistration: (bladeId, item) => ({ bladeId, item }),
+    getRegistrationBladeId: (r) => r.bladeId,
+    getRegistrationItemId: (r) => r.item.id,
+  });
+}
+
+describe("createBladeScopedRegistry", () => {
+  let registry: BladeScopedRegistry<TestItem, TestRegistration>;
+
+  beforeEach(() => {
+    registry = createTestRegistry();
+  });
+
+  it("registers and retrieves items by bladeId", () => {
+    registry.register({ id: "a", label: "A" }, "blade-1");
+    registry.register({ id: "b", label: "B" }, "blade-1");
+
+    const items = registry.get("blade-1");
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.id)).toEqual(["a", "b"]);
+  });
+
+  it("normalizes bladeId to lowercase", () => {
+    registry.register({ id: "a" }, "Blade-1");
+    expect(registry.get("blade-1")).toHaveLength(1);
+    expect(registry.get("BLADE-1")).toHaveLength(1);
+  });
+
+  it("returns empty array for unknown bladeId", () => {
+    expect(registry.get("nonexistent")).toEqual([]);
+  });
+
+  it("returns defensive copy from get()", () => {
+    registry.register({ id: "a" }, "blade-1");
+    const copy = registry.get("blade-1");
+    copy.push({ id: "fake" });
+    expect(registry.get("blade-1")).toHaveLength(1);
+  });
+
+  it("upserts existing items instead of duplicating", () => {
+    registry.register({ id: "a", label: "original" }, "blade-1");
+    registry.register({ id: "a", label: "updated" }, "blade-1");
+
+    const items = registry.get("blade-1");
+    expect(items).toHaveLength(1);
+    expect(items[0].label).toBe("updated");
+  });
+
+  it("tracks registrations in the registrations array", () => {
+    registry.register({ id: "a" }, "blade-1");
+    registry.register({ id: "b" }, "blade-2");
+
+    expect(registry.registrations).toHaveLength(2);
+  });
+
+  it("unregister removes item and registration", () => {
+    registry.register({ id: "a" }, "blade-1");
+    registry.register({ id: "b" }, "blade-1");
+
+    registry.unregister("a", "blade-1");
+
+    expect(registry.get("blade-1")).toHaveLength(1);
+    expect(registry.get("blade-1")[0].id).toBe("b");
+    expect(registry.registrations).toHaveLength(1);
+  });
+
+  it("clear removes all items for a blade", () => {
+    registry.register({ id: "a" }, "blade-1");
+    registry.register({ id: "b" }, "blade-1");
+    registry.register({ id: "c" }, "blade-2");
+
+    registry.clear("blade-1");
+
+    expect(registry.get("blade-1")).toHaveLength(0);
+    expect(registry.get("blade-2")).toHaveLength(1);
+    expect(registry.registrations).toHaveLength(1);
+  });
+
+  it("update modifies an existing item in-place", () => {
+    registry.register({ id: "a", label: "original" }, "blade-1");
+    registry.update("a", "blade-1", { label: "modified" });
+
+    expect(registry.get("blade-1")[0].label).toBe("modified");
+  });
+
+  it("update is a no-op for non-existent item", () => {
+    registry.update("nonexistent", "blade-1", { label: "x" });
+    expect(registry.get("blade-1")).toHaveLength(0);
+  });
+
+  it("isRegistered tracks cross-blade registration count", () => {
+    registry.register({ id: "dup" }, "blade-a");
+    registry.register({ id: "dup" }, "blade-b");
+
+    expect(registry.isRegistered("dup")).toBe(true);
+
+    registry.unregister("dup", "blade-a");
+    expect(registry.isRegistered("dup")).toBe(true);
+
+    registry.unregister("dup", "blade-b");
+    expect(registry.isRegistered("dup")).toBe(false);
+  });
+
+  it("clear decrements registration counts", () => {
+    registry.register({ id: "a" }, "blade-1");
+    registry.register({ id: "a" }, "blade-2");
+
+    registry.clear("blade-1");
+    expect(registry.isRegistered("a")).toBe(true);
+
+    registry.clear("blade-2");
+    expect(registry.isRegistered("a")).toBe(false);
+  });
+});

package/core/services/_internal/createBladeScopedRegistry.ts

@@ -0,0 +1,127 @@
+import { reactive } from "vue";
+
+export interface BladeScopedRegistryOptions<TItem extends { id: string }, TRegistration> {
+  createRegistration: (bladeId: string, item: TItem) => TRegistration;
+  getRegistrationBladeId: (registration: TRegistration) => string;
+  getRegistrationItemId: (registration: TRegistration) => string;
+}
+
+export interface BladeScopedRegistry<TItem extends { id: string }, TRegistration> {
+  readonly registry: Record<string, TItem[]>;
+  readonly registrations: TRegistration[];
+  register(item: TItem, bladeId: string): void;
+  unregister(itemId: string, bladeId: string): void;
+  get(bladeId: string): TItem[];
+  clear(bladeId: string): void;
+  update(id: string, bladeId: string, partial: Partial<TItem>): void;
+  isRegistered(id: string): boolean;
+}
+
+export function createBladeScopedRegistry<TItem extends { id: string }, TRegistration>(
+  options: BladeScopedRegistryOptions<TItem, TRegistration>,
+): BladeScopedRegistry<TItem, TRegistration> {
+  const registry = reactive<Record<string, TItem[]>>({});
+  // Cast needed: reactive() unwraps refs in generics, but our TRegistration types are plain objects
+  const registrations = reactive([]) as TRegistration[];
+  const registrationCountById = reactive(new Map<string, number>());
+
+  function incrementCount(id: string): void {
+    registrationCountById.set(id, (registrationCountById.get(id) ?? 0) + 1);
+  }
+
+  function decrementCount(id: string): void {
+    const count = registrationCountById.get(id);
+    if (!count || count <= 1) {
+      registrationCountById.delete(id);
+      return;
+    }
+    registrationCountById.set(id, count - 1);
+  }
+
+  function register(item: TItem, bladeId: string): void {
+    const normalizedBladeId = bladeId.toLowerCase();
+
+    if (!registry[normalizedBladeId]) {
+      registry[normalizedBladeId] = [];
+    }
+
+    const existing = registry[normalizedBladeId].find((i) => i.id === item.id);
+    if (existing) {
+      Object.assign(existing, item, { bladeId: normalizedBladeId });
+      return;
+    }
+
+    const registryItem: TItem = { ...item, bladeId: normalizedBladeId } as TItem;
+    registry[normalizedBladeId].push(registryItem);
+    registrations.push(options.createRegistration(normalizedBladeId, registryItem));
+    incrementCount(item.id);
+  }
+
+  function unregister(itemId: string, bladeId: string): void {
+    const normalizedBladeId = bladeId.toLowerCase();
+
+    const bladeItems = registry[normalizedBladeId];
+    if (bladeItems) {
+      const itemIndex = bladeItems.findIndex((i) => i.id === itemId);
+      if (itemIndex !== -1) {
+        const [removedItem] = bladeItems.splice(itemIndex, 1);
+        if (removedItem) {
+          decrementCount(removedItem.id);
+        }
+      }
+    }
+
+    const registrationIndex = registrations.findIndex(
+      (r) => options.getRegistrationBladeId(r) === normalizedBladeId && options.getRegistrationItemId(r) === itemId,
+    );
+    if (registrationIndex !== -1) {
+      registrations.splice(registrationIndex, 1);
+    }
+  }
+
+  function get(bladeId: string): TItem[] {
+    const normalizedBladeId = bladeId ? bladeId.toLowerCase() : "";
+    return [...(registry[normalizedBladeId] || [])];
+  }
+
+  function clear(bladeId: string): void {
+    const normalizedBladeId = bladeId.toLowerCase();
+    const bladeItems = registry[normalizedBladeId];
+
+    if (bladeItems) {
+      bladeItems.forEach((item) => decrementCount(item.id));
+      delete registry[normalizedBladeId];
+    }
+
+    const registrationIndexes = registrations
+      .map((r, index) => (options.getRegistrationBladeId(r) === normalizedBladeId ? index : -1))
+      .filter((index) => index !== -1)
+      .reverse();
+
+    registrationIndexes.forEach((index) => {
+      registrations.splice(index, 1);
+    });
+  }
+
+  function update(id: string, bladeId: string, partial: Partial<TItem>): void {
+    const normalizedBladeId = bladeId.toLowerCase();
+    const existing = registry[normalizedBladeId]?.find((i) => i.id === id);
+    if (!existing) return;
+    Object.assign(existing, partial, { bladeId: normalizedBladeId });
+  }
+
+  function isRegistered(id: string): boolean {
+    return registrationCountById.has(id);
+  }
+
+  return {
+    registry,
+    registrations,
+    register,
+    unregister,
+    get,
+    clear,
+    update,
+    isRegistered,
+  };
+}