@equinor/fusion-framework-app 13.0.1 → 14.0.0-next.0

package/dist/types/__tests__/mock/AppMockConfigurator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/mock-app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/mock/msal-hoisting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/initialize-app-modules.d.ts

@@ -0,0 +1,31 @@
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+import type { AppConfigurator } from './AppConfigurator';
+import type { AppModulesInstance, AppEnv } from './types';
+/**
+ * Runs the telemetry wiring, the caller's configuration callback and module
+ * initialization against an already constructed configurator.
+ *
+ * @remarks
+ * Extracted so `mockAppModules` (`@equinor/fusion-framework-app/mock`) can drive the
+ * exact same pipeline against an `AppMockConfigurator` instead of reimplementing
+ * it — the same way `FrameworkConfigurator` and `FrameworkMockConfigurator`
+ * share the framework's `init`.
+ *
+ * @param configurator - The (real or mock) app configurator to run the pipeline on.
+ * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
+ * @param args - Object containing the Fusion instance and the application environment.
+ * @returns The fully initialized application module instance.
+ * @template TModules - Application module descriptors beyond the default set.
+ * @template TRef - The parent Fusion instance type.
+ * @template TEnv - The application environment descriptor.
+ * @template TConfigurator - The (real or mock) `AppConfigurator` subclass driving the pipeline.
+ */
+export declare function initializeAppModules<TModules extends Array<AnyModule> | never, TRef extends Fusion = Fusion, TEnv extends AppEnv = AppEnv, TConfigurator extends AppConfigurator<TModules, TRef['modules'], TEnv> = AppConfigurator<TModules, TRef['modules'], TEnv>>(configurator: TConfigurator, cb: ((configurator: TConfigurator, args: {
+    fusion: TRef;
+    env: TEnv;
+}) => void | Promise<void>) | undefined, args: {
+    fusion: TRef;
+    env: TEnv;
+}): Promise<AppModulesInstance<TModules>>;
+export default initializeAppModules;

package/dist/types/mock/AppMockConfigurator.d.ts

@@ -0,0 +1,142 @@
+import type { FusionModulesInstance } from '@equinor/fusion-framework';
+import type { AnyModule, IModuleConfigurator, ModuleConfigType } from '@equinor/fusion-framework-module';
+import { type IHttpClientConfigurator } from '@equinor/fusion-framework-module-http';
+import { type MsalMockConfigurator } from '@equinor/fusion-framework-module-msal/mock';
+import { AppConfigurator } from '../AppConfigurator.js';
+import type { AppEnv } from '../types.js';
+/**
+ * The real `AppConfigurator`, with the `msal` module it registers backed by
+ * the same test double `FrameworkMockConfigurator` uses. `http` is the real
+ * module — fake a response by registering a short-circuiting middleware
+ * through `.http.addMiddleware(...)` instead of swapping the module out.
+ *
+ * @remarks
+ * Nothing else changes: the same module set (`event`, `http`, `msal`), the same
+ * configuration pipeline and the same lifecycle are used. `configureHttpClient`,
+ * `useFrameworkServiceClient` and any callback written for a real
+ * `AppConfigurator` work against this unchanged.
+ *
+ * `http` and `msal` are pinned early — mirroring `FrameworkMockConfigurator`,
+ * one level down — so `.http` and `.msal` are reachable synchronously, before
+ * `useFrameworkServiceClient` or a `configureModules` callback ever runs.
+ * `event` is deliberately not pinned, for the same reason it isn't in
+ * `FrameworkMockConfigurator`: its `configure` factory reads `ref` to wire
+ * bubbling to a parent event provider, and pinning would freeze that decision
+ * before a `ref` could ever be known.
+ *
+ * @typeParam TModules - Module descriptors beyond the default set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @typeParam TRef - The resolved Fusion modules instance used as a reference during initialization.
+ * @typeParam TEnv - The application environment descriptor.
+ *
+ * @example
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const configurator = new AppMockConfigurator({ manifest });
+ *
+ * configurator.configureHttpClient('catalog', { baseUri: 'https://api.example.com' });
+ * configurator.http.addMiddleware(async (uri, init, next) =>
+ *   uri === 'https://api.example.com/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+ * );
+ * ```
+ */
+export declare class AppMockConfigurator<TModules extends Array<AnyModule> | unknown = unknown, TRef extends FusionModulesInstance = FusionModulesInstance, TEnv extends AppEnv = AppEnv> extends AppConfigurator<TModules, TRef, TEnv> {
+    #private;
+    static readonly className: string;
+    /**
+     * Creates an app configurator backed by the built-in mock modules.
+     *
+     * @param env - The application environment containing manifest, config, and optional basename.
+     */
+    constructor(env: TEnv);
+    /**
+     * No-ops the base constructor's own call to this, since it would otherwise run
+     * before {@link _pin} has anything to redirect `addConfig` at; this class calls
+     * {@link AppConfigurator._configureHttpClientsFromAppConfig} itself once pinned.
+     */
+    protected _configureHttpClientsFromAppConfig(): void;
+    /**
+     * Registers a module configurator, redirecting registrations for a pinned module
+     * at its pinned descriptor.
+     *
+     * @remarks
+     * `configureHttpClient`, `useFrameworkServiceClient` and similar helpers always
+     * pass the real, unpinned module descriptor — the base `addConfig` replaces a
+     * module's descriptor whenever it doesn't recognize the object it's given, even
+     * under the same name, which would otherwise silently un-pin it.
+     *
+     * @param config - The module configurator descriptor to register.
+     * @template T - The module type being configured.
+     * @template TConfig - The resolved configuration type for the module.
+     */
+    addConfig<T extends AnyModule, TConfig = ModuleConfigType<T>>(config: IModuleConfigurator<T, TRef, TConfig>): void;
+    /**
+     * Pins a module to a single configurator instance for the lifetime of this
+     * configurator, so it can be reached by name through {@link _getConfig}.
+     *
+     * @remarks
+     * The module system otherwise builds a fresh configurator from its own
+     * `configure` factory during the configure phase — too late for a test to
+     * reach, and a new instance on every call besides. This replaces that factory
+     * with one that always returns the same instance, and registers the result
+     * under the module's own name.
+     *
+     * An application module supplied through {@link TModules} uses this the same
+     * way `.http` and `.msal` do, to expose its own named accessor:
+     *
+     * ```typescript
+     * class MyAppMockConfigurator extends AppMockConfigurator<[WidgetsModule]> {
+     *   constructor(env: AppEnv) {
+     *     super(env);
+     *     this._pin(widgetsMockModule);
+     *   }
+     *
+     *   public get widgets(): WidgetsMockConfigurator {
+     *     return this._getConfig('widgets');
+     *   }
+     * }
+     * ```
+     *
+     * @param module - The module descriptor to pin a configurator for.
+     * @template TModule - The specific module descriptor type being pinned.
+     * @throws {Error} If the module declares no `configure` factory to pin, or
+     *   the factory returns a promise instead of a configurator — pinning is
+     *   synchronous, so a test can reach the accessor immediately.
+     */
+    protected _pin<TModule extends AnyModule>(module: TModule): void;
+    /**
+     * Returns the configurator pinned for a module by name.
+     *
+     * @param name - The module's name, as passed to {@link _pin}.
+     * @template TConfig - The specific configurator type expected for this module.
+     * @returns The configurator pinned under `name`.
+     * @throws {Error} If no configurator has been pinned for that name.
+     */
+    protected _getConfig<TConfig>(name: string): TConfig;
+    /**
+     * Configures the app's named HTTP clients.
+     *
+     * @remarks
+     * The same {@link IHttpClientConfigurator} the `http` module is configured
+     * from — the real one, not a test double. Every client it builds —
+     * including ones registered through
+     * {@link AppConfigurator.configureHttpClient} or
+     * {@link AppConfigurator.useFrameworkServiceClient} — is reachable here to
+     * register a short-circuiting {@link HttpMiddleware} through
+     * `addMiddleware`, so it answers from that instead of the network.
+     *
+     * @returns The real HTTP configurator.
+     */
+    get http(): IHttpClientConfigurator;
+    /**
+     * Configures the user the app's `msal` module signs in.
+     *
+     * @remarks
+     * The same {@link MsalMockConfigurator} the `msal` module is configured from,
+     * so a change made here is what the module sees.
+     *
+     * @returns The MSAL mock configurator.
+     */
+    get msal(): MsalMockConfigurator;
+}
+export default AppMockConfigurator;

package/dist/types/mock/enable-app-manifest-mock.d.ts

@@ -0,0 +1,33 @@
+import type { FrameworkMockConfigurator } from '@equinor/fusion-framework/mock';
+import { type AppModule } from '@equinor/fusion-framework-module-app';
+import type { AppEnv } from '../types.js';
+/**
+ * Enables the `app` module on a parent framework configurator, wrapping its
+ * client in a {@link MockAppClient} so this app's manifest and config resolve
+ * locally.
+ *
+ * @remarks
+ * The underlying http client is still resolved the same way `AppConfigurator`
+ * resolves it (a pre-configured client, falling back to service discovery), so
+ * a caller pointing `serviceDiscovery` at something else — e.g. a real local
+ * mock server — is honored for every request `MockAppClient` doesn't answer
+ * itself. {@link mockAppModules} uses this to wire its zero-config default
+ * parent; call it directly when building a custom parent (via
+ * {@link mockFramework}) that also needs this app's own manifest servable.
+ *
+ * @param configurator - The parent framework's mock configurator, with `app` in its module set.
+ * @param env - The application environment whose manifest (and optional config) should be served.
+ * @param assetUri - Overrides the base URI a loaded app's script is imported from.
+ * @template TEnv - The application environment descriptor.
+ *
+ * @example Custom service discovery, same manifest resolution
+ * ```typescript
+ * const fusion = await mockFramework<[AppModule]>((configurator) => {
+ *   configurator.serviceDiscovery.setBaseUri('http://localhost:9999');
+ *   enableAppManifestMock(configurator, env);
+ * });
+ * const modules = await mockAppModules(undefined, env, fusion);
+ * ```
+ */
+export declare function enableAppManifestMock<TEnv extends AppEnv>(configurator: FrameworkMockConfigurator<[AppModule]>, env: TEnv, assetUri?: string): void;
+export default enableAppManifestMock;

package/dist/types/mock/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Zero-configuration application module pipelines for tests.
+ *
+ * @remarks
+ * Lets a test initialize an application's real module pipeline — real
+ * `event`/`http`/`msal` modules, real configuration pipeline, real lifecycle —
+ * while the boundaries that reach outside the process are substituted with the
+ * same deterministic fakes {@link https://www.npmjs.com/package/@equinor/fusion-framework | @equinor/fusion-framework}'s
+ * own `/mock` entry point uses. No credentials, no network access and no
+ * running parent portal are required.
+ *
+ * This entry point is test-runner agnostic: it contains no dependency on
+ * Vitest or any other test framework, so the same helpers work under any
+ * runner.
+ *
+ * @packageDocumentation
+ */
+export { mockAppModules, type AppMockConfigureFn } from './mock-app-modules.js';
+export { AppMockConfigurator } from './AppMockConfigurator.js';
+export { enableAppManifestMock } from './enable-app-manifest-mock.js';

package/dist/types/mock/mock-app-modules.d.ts

@@ -0,0 +1,72 @@
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AnyModule } from '@equinor/fusion-framework-module';
+import type { AppEnv, AppModulesInstance } from '../types.js';
+import { AppMockConfigurator } from './AppMockConfigurator.js';
+/**
+ * Configuration callback for {@link mockAppModules}.
+ */
+export type AppMockConfigureFn<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv> = (configurator: AppMockConfigurator<TModules, Fusion['modules'], TEnv>, args: {
+    fusion: Fusion;
+    env: TEnv;
+}) => void | Promise<void>;
+/**
+ * Runs an application's module pipeline with no real credentials required,
+ * from either the parent framework or the app's own `http`/`msal`
+ * registrations.
+ *
+ * @remarks
+ * The real `AppConfigurator` pipeline is run — the real module set, the real
+ * configuration pipeline and the real lifecycle. Only the boundaries that
+ * would need credentials are substituted by default; the `http` module is
+ * the real `HttpClientConfigurator`, so a registered client only avoids the
+ * network for requests a middleware short-circuits with a response — a
+ * client with no matching middleware, or a middleware that calls `next`,
+ * still reaches the real network. A test exercises the wiring an
+ * application actually depends on rather than a reimplementation of it.
+ *
+ * The configurator passed to `cb` is an {@link AppMockConfigurator}, which *is*
+ * an `AppConfigurator`. `useFrameworkServiceClient`, `configureHttpClient` and
+ * any callback written for a real app work against it unchanged.
+ *
+ * `fusion` defaults to a fresh {@link mockFramework} instance with a real `app`
+ * module already enabled and this app's own manifest served at whatever URI
+ * service discovery resolves `'apps'` to, so a test needs no parent Fusion
+ * instance of its own — but an already-mocked (or real) instance can be passed
+ * to compose with other framework-level setup. To point the parent's service
+ * discovery at something else (e.g. a real local mock server) while keeping
+ * the manifest served consistently, build that `fusion` with
+ * {@link mockFramework} and call {@link enableAppManifestMock} yourself,
+ * after customizing `serviceDiscovery`.
+ *
+ * @template TModules - Module descriptors beyond the default set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @template TEnv - The application environment descriptor.
+ * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
+ * @param env - The application environment (manifest, config, basename).
+ * @param fusion - The parent Fusion instance; defaults to a fresh {@link mockFramework} instance.
+ * @returns The initialized application module instance.
+ *
+ * @example Zero configuration
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const modules = await mockAppModules(undefined, { manifest });
+ * ```
+ *
+ * @example Register a client answered by the app's own mocked HTTP module
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const modules = await mockAppModules(
+ *   (configurator) => {
+ *     configurator.useFrameworkServiceClient('portal-api');
+ *     configurator.http.addMiddleware(async (uri, init, next) =>
+ *       uri === 'https://portal-api.fusion.test/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+ *     );
+ *   },
+ *   { manifest },
+ * );
+ *
+ * const items = await modules.http.createClient('portal-api').json('/items');
+ * ```
+ */
+export declare function mockAppModules<TModules extends Array<AnyModule> | unknown = unknown, TEnv extends AppEnv = AppEnv>(cb: AppMockConfigureFn<TModules, TEnv> | undefined, env: TEnv, fusion?: Fusion): Promise<AppModulesInstance<TModules>>;
+export default mockAppModules;

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "13.0.1";
+export declare const version = "14.0.0-next.0";

package/docs/bookmarks.md

@@ -0,0 +1,18 @@
+# Enable Bookmarks
+
+The bookmark module allows applications to save and restore application state.
+
+> **Important:** Import `enableBookmark` from the app-level package, not from
+> `@equinor/fusion-framework-module-bookmark` directly.
+
+```ts
+import { configureModules } from '@equinor/fusion-framework-app';
+import { enableBookmark } from '@equinor/fusion-framework-app/enable-bookmark';
+
+const initialize = configureModules((configurator) => {
+  enableBookmark(configurator);
+});
+```
+
+Payload generators registered through the bookmark module are automatically
+cleaned up when the module is disposed.

package/docs/http-clients.md

@@ -0,0 +1,71 @@
+# Configure HTTP Clients
+
+The `AppConfigurator` can register named HTTP clients from several sources.
+You retrieve a client at runtime with `framework.modules.http.createClient(name)`.
+
+## From Application Config (auto-registration)
+
+Endpoints defined in `app.config.<env>.ts` are **automatically registered as
+named HTTP clients** when the `AppConfigurator` is created — no extra code
+needed in `config.ts`.
+
+```ts
+// app.config.ts
+import { defineAppConfig } from '@equinor/fusion-framework-cli/app';
+
+export default defineAppConfig(() => ({
+  endpoints: {
+    schedule: {
+      url: 'https://schedule-api.example.com',
+      scopes: ['api://schedule-id/.default'],
+    },
+  },
+}));
+```
+
+After initialization, use the client directly:
+
+```ts
+const client = framework.modules.http.createClient('schedule');
+const data = await client.json('/items');
+```
+
+## Via Service Discovery
+
+```ts
+const initialize = configureModules((configurator) => {
+  configurator.useFrameworkServiceClient('people');
+});
+```
+
+## Explicit Registration
+
+Use `configureHttpClient` in `config.ts` when the endpoint is **not** in
+`app.config.ts`, or when you need custom transport behavior such as headers,
+response guards, or a custom client class.
+
+```ts
+configurator.configureHttpClient('custom-api', {
+  baseUri: 'https://custom.api.example.com',
+  defaultScopes: ['api://custom-id/.default'],
+  onCreate: (client) => {
+    client.requestHandler.setHeader('X-Source', 'portal');
+  },
+});
+```
+
+## Resolution Priority
+
+When the same client name is configured in more than one place, the
+highest-priority source wins:
+
+| Priority | Source | Example |
+|----------|--------|---------|
+| 1 (highest) | **Session overrides** | User-specific URL / scopes set at runtime via `sessionStorage` |
+| 2 | **Application config endpoints** | `endpoints` in `app.config.ts` |
+| 3 | **Service-discovery registry** | Resolved via `useFrameworkServiceClient` |
+| 4 (lowest) | **Explicit registration** | `configureHttpClient(name, options)` in `config.ts` |
+
+This means an endpoint defined in `app.config.ts` will override a
+`configureHttpClient` call for the same name, and a session override will
+override both.

package/docs/testing.md

@@ -0,0 +1,105 @@
+# Testing
+
+`@equinor/fusion-framework-app/mock` runs an application's real module pipeline in
+tests — the real `event`/`http`/`msal` modules, the real `AppConfigurator`
+configuration pipeline, and real lifecycle — while only the boundaries that reach
+outside the process (network access, credentials, a running parent portal) are
+substituted with deterministic fakes. This entry point has no dependency on
+Vitest or any other test runner.
+
+```ts
+import { mockAppModules } from '@equinor/fusion-framework-app/mock';
+
+const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+const modules = await mockAppModules(undefined, { manifest });
+```
+
+## `mockAppModules(cb, env, fusion?)`
+
+Runs the same pipeline `configureModules` produces, against a mocked parent.
+`cb` receives an `AppMockConfigurator` — which *is* an `AppConfigurator`, so
+`useFrameworkServiceClient`, `configureHttpClient`, and any callback written for
+a real app work against it unchanged.
+
+- `cb` — configuration callback, or `undefined` to skip it.
+- `env` — the application environment (`manifest`, `config`, `basename`).
+- `fusion` — optional parent Fusion instance. Defaults to a fresh `mockFramework`
+  instance with `app` already enabled and this app's own manifest and config
+  served (see `enableAppManifestMock` below).
+
+```ts
+const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+
+const modules = await mockAppModules(
+  (configurator) => {
+    configurator.useFrameworkServiceClient('portal-api');
+    configurator.http.addMiddleware(async (uri, init, next) =>
+      uri === 'https://portal-api.fusion.test/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+    );
+  },
+  { manifest },
+);
+
+const items = await modules.http.createClient('portal-api').json('/items');
+```
+
+The default parent's own `app` module (not `mockAppModules`'s returned `modules`)
+only resolves `env.manifest`/`env.config` locally for `env.manifest.appKey` —
+setting the current app to any other key falls through to whatever the parent's
+real `app` module would do (a real service-discovery-resolved request, or
+nothing if `serviceDiscovery` was never pointed anywhere):
+
+```ts
+import type { Fusion } from '@equinor/fusion-framework';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+
+await mockAppModules(async (_configurator, { fusion }) => {
+  // the default parent always has `app` enabled; cast narrows the module set
+  // for callers that pass in a parent without it
+  const { app } = (fusion as Fusion<[AppModule]>).modules;
+
+  app.setCurrentApp(env.manifest.appKey);
+  await app.current?.getManifestAsync(); // resolves with env.manifest
+
+  app.setCurrentApp('some-other-app');
+  await app.current?.getManifestAsync(); // rejects — not this app's own manifest
+}, env);
+```
+
+## `enableAppManifestMock(configurator, env)`
+
+Registers the `app` module on a parent `mockFramework` configurator, serving
+`env.manifest` and `env.config` for this app's own `appKey` while delegating
+every other request — other app keys, tagged requests, builds, settings — to
+whatever client service discovery (or a pre-configured http client) would really
+resolve. `mockAppModules` uses this to build its zero-config default parent;
+call it directly when a test needs to customize `serviceDiscovery` (e.g. point
+it at a real local mock server) while keeping this app's own manifest and
+config servable.
+
+```ts
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import type { AppModule } from '@equinor/fusion-framework-module-app';
+import { enableAppManifestMock, mockAppModules } from '@equinor/fusion-framework-app/mock';
+
+const env = { manifest: { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const };
+
+const fusion = await mockFramework<[AppModule]>((configurator) => {
+  configurator.serviceDiscovery.setBaseUri('http://localhost:9999');
+  enableAppManifestMock(configurator, env);
+});
+
+const modules = await mockAppModules(undefined, env, fusion);
+```
+
+## `AppMockConfigurator`
+
+The configurator type passed to `mockAppModules`'s `cb`. It extends the real
+`AppConfigurator`, so any configuration code written against a real app — named
+HTTP clients, service-discovery clients, bookmark setup — works unchanged
+against it in a test.
+
+## Related
+
+- [`@equinor/fusion-framework/mock`](../../framework/docs/testing.md) — mock every framework boundary at once, for building a custom parent `fusion` instance.
+- [`@equinor/fusion-framework-module-app/mock`](../../modules/app/README.md) — the lower-level `MockAppClient` this package's mock wiring is built on.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/fusion-framework-app",
-  "version": "13.0.1",
+  "version": "14.0.0-next.0",
   "description": "",
   "main": "dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
@@ -16,6 +16,10 @@
     "./enable-bookmark": {
       "types": "./dist/types/enable-bookmark.d.ts",
       "import": "./dist/esm/enable-bookmark.js"
+    },
+    "./mock": {
+      "types": "./dist/types/mock/index.d.ts",
+      "import": "./dist/esm/mock/index.js"
     }
   },
   "typesVersions": {
@@ -28,6 +32,9 @@
       ],
       "enable-bookmark": [
         "dist/types/enable-bookmark.d.ts"
+      ],
+      "mock": [
+        "dist/types/mock/index.d.ts"
       ]
     }
   },
@@ -54,23 +61,24 @@
   "dependencies": {
     "lodash.clonedeep": "^4.5.0",
     "rxjs": "^7.8.1",
-    "@equinor/fusion-framework": "8.0.15",
-    "@equinor/fusion-framework-module-app": "8.0.4",
-    "@equinor/fusion-framework-module": "6.1.2",
-    "@equinor/fusion-framework-module-http": "8.0.5",
-    "@equinor/fusion-framework-module-event": "6.0.1",
-    "@equinor/fusion-framework-module-msal": "10.0.2",
-    "@equinor/fusion-framework-module-telemetry": "7.0.2"
+    "@equinor/fusion-framework": "8.1.0-next.0",
+    "@equinor/fusion-framework-module-app": "8.1.0-next.0",
+    "@equinor/fusion-framework-module-event": "6.1.0-next.0",
+    "@equinor/fusion-framework-module-http": "8.1.0-next.0",
+    "@equinor/fusion-framework-module-msal": "11.0.0-next.0",
+    "@equinor/fusion-framework-module": "6.1.3-next.0",
+    "@equinor/fusion-framework-module-telemetry": "8.0.0-next.0"
   },
   "devDependencies": {
     "@types/lodash.clonedeep": "^4.5.9",
     "typescript": "^7.0.2",
-    "@equinor/fusion-framework-module-bookmark": "^4.0.4",
-    "@equinor/fusion-framework-module-state": "^2.0.0"
+    "vitest": "^4.1.10",
+    "@equinor/fusion-framework-module-bookmark": "^4.1.0-next.0",
+    "@equinor/fusion-framework-module-state": "^2.0.1-next.0"
   },
   "peerDependencies": {
-    "@equinor/fusion-framework-module-bookmark": "^4.0.4",
-    "@equinor/fusion-framework-module-state": "^2.0.0"
+    "@equinor/fusion-framework-module-bookmark": "^4.1.0-next.0",
+    "@equinor/fusion-framework-module-state": "^2.0.1-next.0"
   },
   "peerDependenciesMeta": {
     "@equinor/fusion-framework-module-bookmark": {
@@ -81,6 +89,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -b"
+    "build": "tsc -b",
+    "test": "vitest"
   }
 }