@matter/node 0.15.1 → 0.15.2-alpha.0-20250704-2715344f0

package/src/behaviors/wi-fi-network-diagnostics/WiFiNetworkDiagnosticsBehavior.ts

@@ -9,6 +9,7 @@
 import { WiFiNetworkDiagnostics } from "#clusters/wi-fi-network-diagnostics";
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
 import { WiFiNetworkDiagnosticsInterface } from "./WiFiNetworkDiagnosticsInterface.js";
+import { Identity } from "#general";
 
 /**
  * WiFiNetworkDiagnosticsBehavior is the base class for objects that support interaction with
@@ -17,11 +18,13 @@ import { WiFiNetworkDiagnosticsInterface } from "./WiFiNetworkDiagnosticsInterfa
  * This class does not have optional features of WiFiNetworkDiagnostics.Cluster enabled. You can enable additional
  * features using WiFiNetworkDiagnosticsBehavior.with.
  */
-export const WiFiNetworkDiagnosticsBehavior = ClusterBehavior
+export const WiFiNetworkDiagnosticsBehaviorConstructor = ClusterBehavior
     .withInterface<WiFiNetworkDiagnosticsInterface>()
     .for(WiFiNetworkDiagnostics.Cluster);
 
-type WiFiNetworkDiagnosticsBehaviorType = InstanceType<typeof WiFiNetworkDiagnosticsBehavior>;
-export interface WiFiNetworkDiagnosticsBehavior extends WiFiNetworkDiagnosticsBehaviorType {}
-type StateType = InstanceType<typeof WiFiNetworkDiagnosticsBehavior.State>;
-export namespace WiFiNetworkDiagnosticsBehavior { export interface State extends StateType {} }
+export interface WiFiNetworkDiagnosticsBehaviorConstructor extends Identity<typeof WiFiNetworkDiagnosticsBehaviorConstructor> {}
+export const WiFiNetworkDiagnosticsBehavior: WiFiNetworkDiagnosticsBehaviorConstructor = WiFiNetworkDiagnosticsBehaviorConstructor;
+export interface WiFiNetworkDiagnosticsBehavior extends InstanceType<WiFiNetworkDiagnosticsBehaviorConstructor> {}
+export namespace WiFiNetworkDiagnosticsBehavior {
+    export interface State extends InstanceType<typeof WiFiNetworkDiagnosticsBehavior.State> {}
+}

package/src/behaviors/wi-fi-network-diagnostics/WiFiNetworkDiagnosticsClient.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { WiFiNetworkDiagnostics } from "#clusters/wi-fi-network-diagnostics";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "#general";
+
+export const WiFiNetworkDiagnosticsClientConstructor = ClusterBehavior.for(WiFiNetworkDiagnostics.Complete);
+export interface WiFiNetworkDiagnosticsClient extends InstanceType<typeof WiFiNetworkDiagnosticsClientConstructor> {}
+export interface WiFiNetworkDiagnosticsClientConstructor extends Identity<typeof WiFiNetworkDiagnosticsClientConstructor> {}
+export const WiFiNetworkDiagnosticsClient: WiFiNetworkDiagnosticsClientConstructor = WiFiNetworkDiagnosticsClientConstructor;

package/src/behaviors/wi-fi-network-diagnostics/index.ts

@@ -9,3 +9,4 @@
 export * from "./WiFiNetworkDiagnosticsInterface.js";
 export * from "./WiFiNetworkDiagnosticsBehavior.js";
 export * from "./WiFiNetworkDiagnosticsServer.js";
+export * from "./WiFiNetworkDiagnosticsClient.js";

package/src/behaviors/wi-fi-network-management/WiFiNetworkManagementBehavior.ts

@@ -9,16 +9,19 @@
 import { WiFiNetworkManagement } from "#clusters/wi-fi-network-management";
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
 import { WiFiNetworkManagementInterface } from "./WiFiNetworkManagementInterface.js";
+import { Identity } from "#general";
 
 /**
  * WiFiNetworkManagementBehavior is the base class for objects that support interaction with
  * {@link WiFiNetworkManagement.Cluster}.
  */
-export const WiFiNetworkManagementBehavior = ClusterBehavior
+export const WiFiNetworkManagementBehaviorConstructor = ClusterBehavior
     .withInterface<WiFiNetworkManagementInterface>()
     .for(WiFiNetworkManagement.Cluster);
 
-type WiFiNetworkManagementBehaviorType = InstanceType<typeof WiFiNetworkManagementBehavior>;
-export interface WiFiNetworkManagementBehavior extends WiFiNetworkManagementBehaviorType {}
-type StateType = InstanceType<typeof WiFiNetworkManagementBehavior.State>;
-export namespace WiFiNetworkManagementBehavior { export interface State extends StateType {} }
+export interface WiFiNetworkManagementBehaviorConstructor extends Identity<typeof WiFiNetworkManagementBehaviorConstructor> {}
+export const WiFiNetworkManagementBehavior: WiFiNetworkManagementBehaviorConstructor = WiFiNetworkManagementBehaviorConstructor;
+export interface WiFiNetworkManagementBehavior extends InstanceType<WiFiNetworkManagementBehaviorConstructor> {}
+export namespace WiFiNetworkManagementBehavior {
+    export interface State extends InstanceType<typeof WiFiNetworkManagementBehavior.State> {}
+}

package/src/behaviors/wi-fi-network-management/WiFiNetworkManagementClient.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { WiFiNetworkManagementBehavior } from "./WiFiNetworkManagementBehavior.js";
+import { Identity } from "#general";
+
+export const WiFiNetworkManagementClientConstructor = WiFiNetworkManagementBehavior;
+export interface WiFiNetworkManagementClient extends WiFiNetworkManagementBehavior {}
+export interface WiFiNetworkManagementClientConstructor extends Identity<typeof WiFiNetworkManagementClientConstructor> {}
+export const WiFiNetworkManagementClient: WiFiNetworkManagementClientConstructor = WiFiNetworkManagementClientConstructor;

package/src/behaviors/wi-fi-network-management/index.ts

@@ -9,3 +9,4 @@
 export * from "./WiFiNetworkManagementInterface.js";
 export * from "./WiFiNetworkManagementBehavior.js";
 export * from "./WiFiNetworkManagementServer.js";
+export * from "./WiFiNetworkManagementClient.js";

package/src/behaviors/window-covering/WindowCoveringBehavior.ts

@@ -10,6 +10,7 @@ import { WindowCovering } from "#clusters/window-covering";
 import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
 import { WindowCoveringInterface } from "./WindowCoveringInterface.js";
 import { ClusterType } from "#types";
+import { Identity } from "#general";
 
 /**
  * WindowCoveringBehavior is the base class for objects that support interaction with {@link WindowCovering.Cluster}.
@@ -17,11 +18,13 @@ import { ClusterType } from "#types";
  * WindowCovering.Cluster requires you to enable one or more optional features. You can do so using
  * {@link WindowCoveringBehavior.with}.
  */
-export const WindowCoveringBehavior = ClusterBehavior
+export const WindowCoveringBehaviorConstructor = ClusterBehavior
     .withInterface<WindowCoveringInterface>()
     .for(ClusterType(WindowCovering.Base));
 
-type WindowCoveringBehaviorType = InstanceType<typeof WindowCoveringBehavior>;
-export interface WindowCoveringBehavior extends WindowCoveringBehaviorType {}
-type StateType = InstanceType<typeof WindowCoveringBehavior.State>;
-export namespace WindowCoveringBehavior { export interface State extends StateType {} }
+export interface WindowCoveringBehaviorConstructor extends Identity<typeof WindowCoveringBehaviorConstructor> {}
+export const WindowCoveringBehavior: WindowCoveringBehaviorConstructor = WindowCoveringBehaviorConstructor;
+export interface WindowCoveringBehavior extends InstanceType<WindowCoveringBehaviorConstructor> {}
+export namespace WindowCoveringBehavior {
+    export interface State extends InstanceType<typeof WindowCoveringBehavior.State> {}
+}

package/src/behaviors/window-covering/WindowCoveringClient.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
+
+import { WindowCovering } from "#clusters/window-covering";
+import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
+import { Identity } from "#general";
+
+export const WindowCoveringClientConstructor = ClusterBehavior.for(WindowCovering.Complete);
+export interface WindowCoveringClient extends InstanceType<typeof WindowCoveringClientConstructor> {}
+export interface WindowCoveringClientConstructor extends Identity<typeof WindowCoveringClientConstructor> {}
+export const WindowCoveringClient: WindowCoveringClientConstructor = WindowCoveringClientConstructor;

package/src/behaviors/window-covering/index.ts

@@ -9,3 +9,4 @@
 export * from "./WindowCoveringInterface.js";
 export * from "./WindowCoveringBehavior.js";
 export * from "./WindowCoveringServer.js";
+export * from "./WindowCoveringClient.js";

package/src/endpoint/Endpoint.ts

@@ -26,6 +26,7 @@ import { EndpointNumber } from "#types";
 import { RootEndpoint } from "../endpoints/root.js";
 import { Agent } from "./Agent.js";
 import { Behaviors } from "./properties/Behaviors.js";
+import { Commands } from "./properties/Commands.js";
 import { EndpointContainer } from "./properties/EndpointContainer.js";
 import { EndpointInitializer } from "./properties/EndpointInitializer.js";
 import { EndpointLifecycle } from "./properties/EndpointLifecycle.js";
@@ -56,6 +57,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
     #construction: Construction<Endpoint<T>>;
     #stateView = {} as Immutable<SupportedBehaviors.StateOf<T["behaviors"]>>;
     #events = {} as SupportedBehaviors.EventsOf<T["behaviors"]>;
+    #commands?: Commands<T>;
     #activity?: NodeActivity;
 
     /**
@@ -242,6 +244,26 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
         });
     }
 
+    /**
+     * Commands for all behaviors keyed by behavior ID.
+     */
+    get commands() {
+        if (this.#commands === undefined) {
+            this.#commands = Commands(this);
+        }
+        return this.#commands;
+    }
+
+    /**
+     * Commands for a specific behavior.
+     */
+    commandsOf<T extends Behavior.Type>(type: T) {
+        if (!this.behaviors.has(type)) {
+            throw new ImplementationError(`Behavior ${type.id} is not supported by this endpoint`);
+        }
+        return this.commands[type.id] as unknown as Commands.OfBehavior<T>;
+    }
+
     /**
      * Events for all behaviors keyed by behavior ID.
      */
@@ -386,20 +408,19 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
             return;
         }
         if (this.#owner) {
-            throw new ImplementationError("Endpoint owner cannot be reassigned");
-        }
-        if (owner === undefined) {
-            throw new ImplementationError("Endpoint owner must be defined");
+            this.#container.delete(this);
         }
 
         this.#owner = owner;
 
-        try {
-            this.#container.add(this);
-        } catch (e) {
-            this.#container.delete(this);
-            this.#owner = undefined;
-            throw e;
+        if (owner) {
+            try {
+                this.#container.add(this);
+            } catch (e) {
+                this.#container.delete(this);
+                this.#owner = undefined;
+                throw e;
+            }
         }
     }
 
@@ -563,9 +584,13 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
             this.#activity = this.env.get(NodeActivity);
         }
 
-        return OfflineContext.act(purpose, this.#activity, context => {
-            return actor(context.agentFor(this));
-        });
+        return OfflineContext.act(
+            purpose,
+            context => {
+                return actor(context.agentFor(this));
+            },
+            { activity: this.#activity },
+        );
     }
 
     /**

package/src/endpoint/index.ts

@@ -7,6 +7,5 @@
 export * from "./Agent.js";
 export * from "./Endpoint.js";
 export * from "./properties/index.js";
-export * from "./server/index.js";
 export * from "./storage/index.js";
 export * from "./type/index.js";

package/src/endpoint/properties/Behaviors.ts

@@ -29,7 +29,6 @@ import { FeatureSet } from "#model";
 import { ProtocolService } from "#node/server/ProtocolService.js";
 import { ClusterTypeProtocol, FabricManager, Val } from "#protocol";
 import { ClusterType, VoidSchema } from "#types";
-import { DescriptorServer } from "../../behaviors/descriptor/DescriptorServer.js";
 import type { Agent } from "../Agent.js";
 import type { Endpoint } from "../Endpoint.js";
 import { EndpointVariableService } from "../EndpointVariableService.js";
@@ -160,11 +159,6 @@ export class Behaviors {
         this.#supported = type.behaviors;
         this.#options = options;
 
-        // DescriptorBehavior is unequivocally mandatory
-        if (!this.#supported.descriptor) {
-            this.#supported.descriptor = DescriptorServer;
-        }
-
         for (const id in this.#supported) {
             const type = this.#supported[id];
             if (!(type.prototype instanceof Behavior)) {
@@ -239,7 +233,7 @@ export class Behaviors {
         const activity = this.#endpoint.env.get(NodeActivity);
 
         // Perform initialization
-        let promise = OfflineContext.act(`initialize<${this.#endpoint}>`, activity, initializeBehaviors);
+        let promise = OfflineContext.act(`initialize<${this.#endpoint}>`, initializeBehaviors, { activity });
 
         // Once behaviors are ready the endpoint we consider the endpoint "ready"
         const onReady = () => {
@@ -266,10 +260,6 @@ export class Behaviors {
      * Add behavior support dynamically at runtime.  Typically called via {@link Agent.require}.
      */
     require<T extends Behavior.Type>(type: T, options?: Behavior.Options<T>) {
-        if (options) {
-            this.#options[type.id] = options;
-        }
-
         if (this.#supported[type.id]) {
             if (!this.has(type)) {
                 throw new ImplementationError(
@@ -279,12 +269,7 @@ export class Behaviors {
             return;
         }
 
-        if (this.#supported === this.#endpoint.type.behaviors) {
-            this.#supported = { ...this.#supported };
-        }
-        this.#supported[type.id] = type;
-
-        this.#augmentEndpoint(type);
+        this.inject(type, options);
 
         this.#endpoint.lifecycle.change(EndpointLifecycle.Change.ServersChanged);
 
@@ -429,7 +414,31 @@ export class Behaviors {
             }
         };
 
-        await OfflineContext.act(`close<${this.#endpoint}>`, this.#endpoint.env.get(NodeActivity), dispose);
+        await OfflineContext.act(
+            `close<${this.#endpoint}>`,
+            dispose,
+
+            // Note - do not close in an activity because this can cause deadlock
+            //, {
+            //    activity: this.#endpoint.env.get(NodeActivity),
+            //},
+        );
+    }
+
+    /**
+     * Add support for an additional behavior statically.  Should only be invoked prior to initialization.
+     */
+    inject(type: Behavior.Type, options?: Behavior.Options) {
+        if (options) {
+            this.#options[type.id] = options;
+        }
+
+        if (this.#supported === this.#endpoint.type.behaviors) {
+            this.#supported = { ...this.#supported };
+        }
+        this.#supported[type.id] = type;
+
+        this.#augmentEndpoint(type);
     }
 
     /**
@@ -553,13 +562,17 @@ export class Behaviors {
     }
 
     #activateLate(type: Behavior.Type) {
-        const result = OfflineContext.act("behavior-late-activation", this.#endpoint.env.get(NodeActivity), context => {
-            this.activate(type, context.agentFor(this.#endpoint));
-
-            // Agent must remain active until backing is initialized
-            const backing = this.#backingFor(type);
-            return backing.construction.ready;
-        });
+        const result = OfflineContext.act(
+            "behavior-late-activation",
+            context => {
+                this.activate(type, context.agentFor(this.#endpoint));
+
+                // Agent must remain active until backing is initialized
+                const backing = this.#backingFor(type);
+                return backing.construction.ready;
+            },
+            { activity: this.#endpoint.env.get(NodeActivity) },
+        );
 
         if (MaybePromise.is(result)) {
             result.then(undefined, error => {
@@ -645,16 +658,10 @@ export class Behaviors {
      * Updates endpoint "state" and "events" properties to include properties for a supported behavior.
      */
     #augmentEndpoint(type: Behavior.Type) {
-        const stateDescriptor = {
-            get: () => {
-                return this.#backingFor(type).stateView;
-            },
-
-            enumerable: true,
-        };
-        Object.defineProperty(this.#endpoint.state, type.id, stateDescriptor);
+        const get = () => this.#backingFor(type).stateView;
+        Object.defineProperty(this.#endpoint.state, type.id, { get, enumerable: true });
         if (type.schema?.id !== undefined) {
-            Object.defineProperty(this.#endpoint.state, type.schema.id, stateDescriptor);
+            Object.defineProperty(this.#endpoint.state, type.schema.id, { get });
         }
 
         let events: undefined | EventEmitter;

package/src/endpoint/properties/Commands.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Behavior } from "#behavior/Behavior.js";
+import type { ActionContext } from "#behavior/context/ActionContext.js";
+import { OfflineContext } from "#behavior/context/server/OfflineContext.js";
+import type { Endpoint } from "#endpoint/Endpoint.js";
+import type { EndpointType } from "#endpoint/type/EndpointType.js";
+import { NotImplementedError } from "#general";
+
+export type Commands<T extends EndpointType> = {
+    [K in keyof T["behaviors"]]: Commands.OfBehavior<T["behaviors"][K]>;
+};
+
+export function Commands<T extends EndpointType = EndpointType.Empty>(endpoint: Endpoint<T>) {
+    const commands: Record<string, unknown> = {};
+
+    return new Proxy(commands, {
+        get(target, property, receiver) {
+            if (Object.hasOwn(commands, property)) {
+                return commands[property as keyof typeof commands];
+            }
+
+            const behavior = (endpoint.behaviors.supported as Record<string, Behavior.Type>)[property as string];
+            if (typeof behavior === "function" && "schema" in behavior) {
+                return (commands[property as keyof typeof commands] = BehaviorCommands(endpoint, behavior));
+            }
+
+            return Reflect.get(target, property, receiver);
+        },
+    }) as Commands<T>;
+}
+
+function BehaviorCommands(endpoint: Endpoint, type: Behavior.Type) {
+    return new Proxy(
+        {},
+        {
+            get(target, property, receiver) {
+                if (typeof property !== "string" || property in Object.prototype) {
+                    return Reflect.get(target, property, receiver);
+                }
+
+                return Implementation(endpoint, type, property);
+            },
+        },
+    );
+}
+
+function Implementation(endpoint: Endpoint, type: Behavior.Type, name: string): Commands.Command {
+    return {
+        [name](input: unknown, context?: ActionContext) {
+            // Invoke with existing context
+            if (context) {
+                return Promise.resolve(invokerFor(context)(input, context));
+            }
+
+            // Invoke with a dedicated context
+            const context2 = OfflineContext.open(`invoke-${name}`);
+            try {
+                return Promise.resolve(context2.resolve(invokerFor(context2)(input, context)));
+            } catch (e) {
+                return Promise.resolve(context2.reject(e));
+            }
+
+            // Create function to perform invocation
+            function invokerFor(context: ActionContext) {
+                const agent = context.agentFor(endpoint);
+                const behavior = agent.get(type);
+                const method = (behavior as unknown as Record<string, Commands.Command>)[name];
+                if (typeof method !== "function") {
+                    throw new NotImplementedError(`Command ${name} is not implemented`);
+                }
+                return method.bind(behavior);
+            }
+        },
+    }[name];
+}
+
+export namespace Commands {
+    export interface Command<C extends (arg: unknown) => unknown = (arg: unknown) => unknown> {
+        (input: Parameters<C>[0], context?: ActionContext): Promise<Awaited<ReturnType<C>>>;
+    }
+
+    export type OfBehavior<T extends Behavior.Type> = {
+        [K in keyof InstanceType<T>]: InstanceType<T>[K] extends (arg: any) => any
+            ? Command<InstanceType<T>[K]>
+            : never;
+    };
+}

package/src/endpoint/properties/EndpointContainer.ts

@@ -21,10 +21,18 @@ export class EndpointContainer<T extends Endpoint = Endpoint>
         this.#owner = endpoint;
     }
 
-    get(id: string) {
-        for (const child of this) {
-            if (child.maybeId === id) {
-                return child;
+    get(id: string | number) {
+        if (typeof id === "number") {
+            for (const child of this) {
+                if (child.maybeNumber === id) {
+                    return child;
+                }
+            }
+        } else {
+            for (const child of this) {
+                if (child.maybeId === id) {
+                    return child;
+                }
             }
         }
     }

package/src/endpoint/properties/Parts.ts

@@ -42,7 +42,7 @@ export class Parts extends EndpointContainer implements MutableSet<Endpoint, End
         }
 
         // Insertion validation is only possible in a fully configured node. If we are not yet installed then an
-        // ancestor will handle validation when we installed
+        // ancestor will handle validation when we install
         if (this.owner.lifecycle.isReady) {
             this.#validateInsertion(endpoint, endpoint);
         }

package/src/endpoint/storage/index.ts

@@ -4,5 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export * from "./DatasourceStore.js";
-export * from "./EndpointStore.js";
+export * from "../../storage/client/DatasourceCache.js";
+export * from "../../storage/server/DatasourceStore.js";
+export * from "../../storage/server/ServerEndpointStore.js";

package/src/index.ts

@@ -11,4 +11,5 @@ export * from "./behavior/index.js";
 export * from "./endpoint/index.js";
 export * from "./loader/index.js";
 export * from "./node/index.js";
+export * from "./storage/index.js";
 export * from "./tags/index.js";

package/src/loader/loader.ts

@@ -6,7 +6,7 @@
 
 import { Behavior } from "#behavior/Behavior.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
-import { camelize, decamelize, ImplementationError, MaybePromise } from "#general";
+import { camelize, decamelize, ImportError, MaybePromise } from "#general";
 
 // Must load from public export so node selects the correct format
 import { load } from "@matter/node/load";
@@ -31,6 +31,15 @@ export namespace loader {
         ) as MaybePromise<Behavior.Type>;
     }
 
+    export function server(name: string) {
+        const exportName = `${camelize(name, true)}Server`;
+        return doLoad(
+            `behavior ${name}`,
+            exportName,
+            `../behaviors/${decamelize(name)}/${exportName}.js`,
+        ) as MaybePromise<Behavior.Type>;
+    }
+
     export function device(name: string) {
         const exportName = `${camelize(name, true)}Device`;
         return doLoad(
@@ -48,6 +57,8 @@ export namespace loader {
             `../endpoints/${decamelize(name)}.js`,
         ) as MaybePromise<EndpointType>;
     }
+
+    export const registry = {} as Record<string, Record<string, {} | undefined> | undefined>;
 }
 
 function doLoad(description: string, exportName: string, path: string) {
@@ -74,6 +85,6 @@ function doLoad(description: string, exportName: string, path: string) {
     }
 
     function failure() {
-        throw new ImplementationError(`No implementation available for ${description}`);
+        throw new ImportError(`No implementation available for ${description}`);
     }
 }

package/src/loader/static.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { loader } from "./loader.js";
+
+/**
+ * This static version of the loader only responds with components loaded statically.
+ *
+ * You must load components required separately into {@link loader.registry}.
+ */
+export function load(path: string): {} {
+    const parsed = path.match(/([^/]+)\/[^/]+\/[^/]+\.js/);
+
+    if (parsed) {
+        const [, group] = parsed;
+        return loader.registry[group] ?? {};
+    }
+
+    return {};
+}