ptech-shell-dev 1.6.7 → 1.8.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { LogLevel, RealtimeEnvelope, UserService, RequestContextService, RealtimeService, Lang, User, I18nService, ApiClient, NavigationService, ConfigService, PermissionService, SharedStateService, ObservabilityService, NotificationService, AnalyticsService, ObservabilityConfigPatch, ApiErrorPayload, ApiValidationErrors, ApiRetryOptions, MsalAccountInfoLike, NavigationAction, NavigationTo, NavigationNavigateOptions } from 'ptech-shell-sdk';
+import { LogLevel, RealtimeEnvelope, UserService, RequestContextService, RealtimeService, Lang, User, I18nService, ApiClient, NavigationService, ConfigService, PermissionService, SharedStateService, ObservabilityService, NotificationService, AnalyticsService, TenantService, AppSettingsService, ObservabilityConfigPatch, AppSettings, ApiErrorPayload, ApiValidationErrors, ApiRetryOptions, MsalAccountInfoLike, NavigationAction, NavigationTo, NavigationNavigateOptions } from 'ptech-shell-sdk';
 
 type ObservabilityTelemetryEvent = {
     level: LogLevel;
@@ -74,20 +74,24 @@ type StandaloneServices = {
     observability: ObservabilityService;
     notification: NotificationService;
     analytics: AnalyticsService;
+    tenantService: TenantService;
+    appSettingsService: AppSettingsService;
 };
 type ServiceRegisterMode = 'if-missing' | 'always';
 type StandaloneInitOptions = {
     /**
      * API base URL when running standalone.
-     * Example: http://localhost:4000
+     * @default 'http://localhost:4000'
      */
     apiBase?: string;
     /**
      * Default language for standalone.
+     * @default 'vi'
      */
     lang?: Lang;
     /**
      * Seed user for standalone. (Optional)
+     * @default { id: 'dev', name: 'Dev User' }
      */
     user?: User | null;
     /**
@@ -116,8 +120,47 @@ type StandaloneInitOptions = {
      * - always: replace any existing service for the token.
      */
     registerMode?: ServiceRegisterMode;
+    /**
+     * Default path for standalone navigation service.
+     * @default '/standalone'
+     */
+    navigationPath?: string;
+    /**
+     * Feature flags seed for standalone config service.
+     * Merged with built-in defaults.
+     */
+    featureFlags?: Record<string, boolean>;
+    /**
+     * Runtime config overrides for standalone config service.
+     */
+    runtimeConfig?: {
+        envName?: string;
+        apiBase?: string;
+    };
+    /**
+     * Seed values for the standalone tenant service.
+     * Defaults to `{ tenantId: 'dev-tenant', tenantSlug: 'dev' }`.
+     */
+    tenant?: {
+        tenantId?: string | null;
+        tenantSlug?: string | null;
+    };
+    /**
+     * Seed/loader for the standalone app settings service.
+     * - `seed`: static per-appKey map returned by `load()`.
+     * - `fetcher`: override that takes precedence over seed.
+     */
+    appSettings?: {
+        seed?: Readonly<Record<string, AppSettings>>;
+        fetcher?: (appKey: string) => Promise<AppSettings>;
+    };
 };
 
+/**
+ * Creates all standalone service instances without registering them.
+ * Useful for testing or when you need direct access to services.
+ */
+declare function createTestServices(options?: StandaloneInitOptions): StandaloneServices;
 /**
  * Initialize "safe defaults" so a remote app can run standalone without the host.
  *
@@ -125,6 +168,21 @@ type StandaloneInitOptions = {
  * But if host doesn't (or remote is standalone), this provides mocks.
  */
 declare function initStandaloneServices(options?: StandaloneInitOptions): void;
+/**
+ * Create a preset factory with default options baked in.
+ * Useful for projects that want consistent defaults across remotes.
+ *
+ * @example
+ * // In a shared config file:
+ * export const initHrmServices = createDevPreset({
+ *   apiBase: 'http://localhost:5000',
+ *   lang: 'en',
+ * });
+ *
+ * // In each remote's bootstrap:
+ * initHrmServices({ user: { id: 'admin', name: 'Admin' } });
+ */
+declare function createDevPreset(defaults: StandaloneInitOptions): (overrides?: StandaloneInitOptions) => void;
 
 type CreateStandaloneApiClientOptions = {
     apiBase: string;
@@ -143,6 +201,12 @@ type CreateStandaloneApiClientOptions = {
      */
     getRequestContext?: () => RequestContextService | undefined;
     requestContext?: RequestContextService;
+    /**
+     * Optional dynamic lookup for tenant service; header `X-Tenant-Id` is injected
+     * when the resolved snapshot has a non-empty `tenantId`.
+     */
+    getTenantService?: () => TenantService | undefined;
+    tenantService?: TenantService;
     defaultAuthScopes?: string[];
     defaultTimeoutMs?: number;
     defaultRetries?: ApiRetryOptions | false;
@@ -194,6 +258,32 @@ declare function isApiError(value: unknown): value is ApiError;
  */
 declare function createStandaloneApiClient(options: string | CreateStandaloneApiClientOptions): ApiClient;
 
+type CreateStandaloneAppSettingsServiceOptions = {
+    /**
+     * Static seed settings keyed by appKey.
+     * Returned instantly from `load()` and `get()` for dev/test scenarios.
+     */
+    seed?: Readonly<Record<string, AppSettings>>;
+    /**
+     * Optional async loader, overrides seed when provided.
+     * Useful when tests want to simulate latency or network failures.
+     */
+    fetcher?: (appKey: string) => Promise<AppSettings>;
+};
+/**
+ * WHY:
+ * - In-memory per-appKey settings store for standalone remote development.
+ * WHEN TO USE:
+ * - Use via initStandaloneServices so remotes can call `load(appKey)` without a host.
+ * WHEN NOT TO USE:
+ * - Do not use in production — host fetches from backend and owns cache invalidation.
+ * INVARIANTS:
+ * - `get()` returns null until `load()` resolves for that appKey.
+ * - `invalidate()` with no args drops all cached entries.
+ * - Listeners are scoped per appKey; invalidate emits for affected keys only.
+ */
+declare function createStandaloneAppSettingsService(options?: CreateStandaloneAppSettingsServiceOptions): AppSettingsService;
+
 type UiApiError = {
     i18nKey: string;
     params: Record<string, string | number>;
@@ -362,6 +452,23 @@ type CreateRequestContextServiceOptions = {
  */
 declare function createRequestContextService(options?: CreateRequestContextServiceOptions): RequestContextService;
 
+type CreateStandaloneTenantServiceOptions = {
+    tenantId?: string | null;
+    tenantSlug?: string | null;
+};
+/**
+ * WHY:
+ * - Provides a minimal in-memory TenantService for standalone remote dev.
+ * WHEN TO USE:
+ * - Use via initStandaloneServices when a remote runs without host.
+ * WHEN NOT TO USE:
+ * - Do not use in production — host registers its own tenant service.
+ * INVARIANTS:
+ * - getSnapshot returns a copy, never the mutable internal reference.
+ * - setTenant emits only when either field actually changes.
+ */
+declare function createStandaloneTenantService(options?: CreateStandaloneTenantServiceOptions): TenantService;
+
 /**
  * WHY:
  * - Provides mock user/session/auth token behavior for standalone shell development.
@@ -376,4 +483,4 @@ declare function createRequestContextService(options?: CreateRequestContextServi
  */
 declare function createStandaloneUserService(seedUser: User | null): UserService;
 
-export { ApiError, type CreateMsalUserServiceOptions, type CreateReactRouterNavigationAdapterOptions, type CreateStandaloneApiClientOptions, type CreateStandaloneObservabilityServiceOptions, type CreateStandaloneRealtimeServiceOptions, type MsalBrowserInstanceLike, type ObservabilityTelemetryEvent, type ObservabilityTelemetrySink, type ReactRouterCreateHrefFunctionLike, type ReactRouterLocationLike, type ReactRouterNavigateFunctionLike, type ReactRouterNavigationAdapter, type ReactRouterNavigationCapabilities, type RealtimeReconnectOptions, type RealtimeTransport, type RealtimeTransportConnectContext, type ServiceRegisterMode, type StandaloneInitOptions, type StandaloneServices, type UiApiError, createMsalUserService, createReactRouterNavigationAdapter, createRequestContextService, createStandaloneApiClient, createStandaloneI18nService, createStandaloneRealtimeService, createStandaloneUserService, initStandaloneServices, isApiError, mapApiErrorToUiError };
+export { ApiError, type CreateMsalUserServiceOptions, type CreateReactRouterNavigationAdapterOptions, type CreateStandaloneApiClientOptions, type CreateStandaloneObservabilityServiceOptions, type CreateStandaloneRealtimeServiceOptions, type MsalBrowserInstanceLike, type ObservabilityTelemetryEvent, type ObservabilityTelemetrySink, type ReactRouterCreateHrefFunctionLike, type ReactRouterLocationLike, type ReactRouterNavigateFunctionLike, type ReactRouterNavigationAdapter, type ReactRouterNavigationCapabilities, type RealtimeReconnectOptions, type RealtimeTransport, type RealtimeTransportConnectContext, type ServiceRegisterMode, type StandaloneInitOptions, type StandaloneServices, type UiApiError, createDevPreset, createMsalUserService, createReactRouterNavigationAdapter, createRequestContextService, createStandaloneApiClient, createStandaloneAppSettingsService, createStandaloneI18nService, createStandaloneRealtimeService, createStandaloneTenantService, createStandaloneUserService, createTestServices, initStandaloneServices, isApiError, mapApiErrorToUiError };

package/dist/index.js

@@ -66,6 +66,7 @@ var DEFAULT_RETRY_OPTIONS = {
 var TRACE_HEADER = "traceparent";
 var CORRELATION_HEADER = "x-correlation-id";
 var CORRELATION_HEADERS = ["x-correlation-id", "x-request-id"];
+var TENANT_HEADER = "x-tenant-id";
 var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
 function isApiError(value) {
   return value instanceof ApiError;
@@ -354,6 +355,15 @@ function normalizeRetryOptions(input, defaultRetryOptions) {
 function shouldRetryResponse(response, retry) {
   return retry.retryOnStatuses.has(response.status);
 }
+async function disposeRetryResponse(response) {
+  if (!response.body || typeof response.body.cancel !== "function") {
+    return;
+  }
+  try {
+    await response.body.cancel();
+  } catch {
+  }
+}
 function shouldRetryError(error) {
   return error.isNetworkError && error.code !== "aborted";
 }
@@ -409,6 +419,7 @@ function resolveCreateOptions(input) {
     getUserService: input.getUserService ?? (input.userService ? () => input.userService : void 0),
     getNotificationService: input.getNotificationService ?? (input.notificationService ? () => input.notificationService : void 0),
     getRequestContext: input.getRequestContext ?? (input.requestContext ? () => input.requestContext : void 0),
+    getTenantService: input.getTenantService ?? (input.tenantService ? () => input.tenantService : void 0),
     defaultAuthScopes: input.defaultAuthScopes ?? [],
     defaultTimeoutMs: input.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
     defaultRetries: input.defaultRetries ?? DEFAULT_RETRY_OPTIONS
@@ -430,6 +441,19 @@ function applyRequestContextHeaders(headers, options) {
     headers.set(CORRELATION_HEADER, context.correlationId);
   }
 }
+function applyTenantHeader(headers, options) {
+  if (headers.has(TENANT_HEADER)) {
+    return;
+  }
+  const tenantService = options.getTenantService?.();
+  if (!tenantService) {
+    return;
+  }
+  const tenantId = tenantService.getSnapshot().tenantId;
+  if (tenantId && tenantId.length > 0) {
+    headers.set(TENANT_HEADER, tenantId);
+  }
+}
 function syncResponseContext(response, options) {
   const contextService = options.getRequestContext?.();
   if (!contextService) {
@@ -522,6 +546,7 @@ async function executeRaw(requestOptions, options) {
   const timeoutMs = requestOptions.timeoutMs ?? options.defaultTimeoutMs;
   const headers = new Headers(requestOptions.headers);
   applyRequestContextHeaders(headers, options);
+  applyTenantHeader(headers, options);
   await applyAuthorization(headers, requestOptions, options);
   const url = resolveUrl(options.apiBase, requestOptions.url);
   const body = resolveBody(requestOptions.body, headers);
@@ -541,6 +566,7 @@ async function executeRaw(requestOptions, options) {
       );
       syncResponseContext(response, options);
       if (retry && shouldUseRetry && attempt < maxAttempts && shouldRetryResponse(response, retry)) {
+        await disposeRetryResponse(response);
         const delayMs = computeRetryDelayMs(attempt, retry);
         await sleep(delayMs, requestOptions.signal);
         continue;
@@ -601,6 +627,7 @@ function createStandaloneApiClient(options) {
     fetch: async (input, init) => {
       const headers = new Headers(init?.headers);
       applyRequestContextHeaders(headers, resolvedOptions);
+      applyTenantHeader(headers, resolvedOptions);
       await applyAuthorization(
         headers,
         {
@@ -635,6 +662,69 @@ function createStandaloneApiClient(options) {
   };
 }
 
+// src/services/appSettings.ts
+function createStandaloneAppSettingsService(options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  function emit(appKey) {
+    const group = listeners.get(appKey);
+    if (!group) return;
+    for (const listener of group) {
+      listener();
+    }
+  }
+  async function resolveSettings(appKey) {
+    if (options.fetcher) {
+      return options.fetcher(appKey);
+    }
+    return options.seed?.[appKey] ?? {};
+  }
+  return {
+    get: (appKey) => cache.get(appKey) ?? null,
+    load: async (appKey) => {
+      const existing = cache.get(appKey);
+      if (existing) {
+        return existing;
+      }
+      const settings = await resolveSettings(appKey);
+      const snapshot = {
+        settings,
+        version: 1
+      };
+      cache.set(appKey, snapshot);
+      emit(appKey);
+      return snapshot;
+    },
+    subscribe: (appKey, listener) => {
+      let group = listeners.get(appKey);
+      if (!group) {
+        group = /* @__PURE__ */ new Set();
+        listeners.set(appKey, group);
+      }
+      group.add(listener);
+      return () => {
+        group?.delete(listener);
+        if (group && group.size === 0) {
+          listeners.delete(appKey);
+        }
+      };
+    },
+    invalidate: (appKey) => {
+      if (appKey === void 0) {
+        const affected = Array.from(cache.keys());
+        cache.clear();
+        for (const key of affected) {
+          emit(key);
+        }
+        return;
+      }
+      if (cache.delete(appKey)) {
+        emit(appKey);
+      }
+    }
+  };
+}
+
 // src/services/config.ts
 import { FEATURE_FLAGS } from "ptech-shell-sdk";
 var DEFAULT_FLAGS = {
@@ -1079,14 +1169,13 @@ import {
 } from "ptech-shell-sdk";
 var DEFAULT_PERMISSIONS = listPermissionsByRole(USER_ROLES.authenticated);
 function createStandalonePermissionService(initialPermissions = DEFAULT_PERMISSIONS) {
-  const listeners = /* @__PURE__ */ new Set();
   const permissions = new Set(initialPermissions);
   return {
     can: (permission) => permissions.has(permission),
     list: () => Array.from(permissions.values()),
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
+    subscribe: () => {
+      return () => {
+      };
     }
   };
 }
@@ -1121,8 +1210,8 @@ function createNoopTransport() {
   let disconnectListener;
   return {
     start: async () => {
-      messageListener = messageListener;
-      disconnectListener = disconnectListener;
+      void messageListener;
+      void disconnectListener;
     },
     stop: async () => void 0,
     onMessage: (listener) => {
@@ -1169,6 +1258,7 @@ function createStandaloneRealtimeService(options = {}) {
   let unbindMessage;
   let unbindDisconnect;
   let inFlightStart = null;
+  let lifecycleVersion = 0;
   function emitStateChanged() {
     for (const listener of listeners) {
       listener();
@@ -1259,6 +1349,7 @@ function createStandaloneRealtimeService(options = {}) {
       return inFlightStart;
     }
     inFlightStart = (async () => {
+      const startVersion = lifecycleVersion;
       stopRequested = false;
       clearReconnectTimer();
       setState(activeAttempt > 0 ? "reconnecting" : "connecting");
@@ -1271,6 +1362,14 @@ function createStandaloneRealtimeService(options = {}) {
           traceId: context.traceId,
           correlationId: context.correlationId
         });
+        if (stopRequested || startVersion !== lifecycleVersion) {
+          try {
+            await nextTransport.stop();
+          } catch {
+          }
+          setState("disconnected");
+          return;
+        }
         transport = nextTransport;
         await bindTransportListeners(nextTransport);
         activeAttempt = 0;
@@ -1278,6 +1377,10 @@ function createStandaloneRealtimeService(options = {}) {
       } catch {
         transport = null;
         unbindTransportListeners();
+        if (stopRequested || startVersion !== lifecycleVersion) {
+          setState("disconnected");
+          return;
+        }
         scheduleReconnect();
       }
     })();
@@ -1288,6 +1391,7 @@ function createStandaloneRealtimeService(options = {}) {
     }
   }
   async function stopInternal() {
+    lifecycleVersion += 1;
     stopRequested = true;
     clearReconnectTimer();
     const current = transport;
@@ -1460,23 +1564,13 @@ function createStandaloneSharedStateService() {
         return;
       }
       const listeners = requestListenersByKey.get(request.key);
-      if (!listeners || listeners.size === 0) {
-        throw new Error(
-          `No owner request handler for key "${request.key}". Owner is "${current.owner}".`
-        );
-      }
-      let handled = false;
-      for (const sub of listeners) {
-        if (sub.owner === current.owner) {
-          handled = true;
-          sub.listener(request);
-        }
-      }
-      if (!handled) {
+      const ownerListener = listeners?.get(current.owner);
+      if (!ownerListener) {
         throw new Error(
           `Owner "${current.owner}" has no active request handler for key "${request.key}".`
         );
       }
+      ownerListener(request);
     },
     subscribeKey: (key, listener) => {
       let listeners = listenersByKey.get(key);
@@ -1496,17 +1590,18 @@ function createStandaloneSharedStateService() {
     subscribeRequests: (key, owner, listener) => {
       let listeners = requestListenersByKey.get(key);
       if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
+        listeners = /* @__PURE__ */ new Map();
         requestListenersByKey.set(key, listeners);
       }
-      const sub = {
-        owner,
-        listener
-      };
-      listeners.add(sub);
+      listeners.set(owner, listener);
       return () => {
         const current = requestListenersByKey.get(key);
-        current?.delete(sub);
+        if (!current) {
+          return;
+        }
+        if (current.get(owner) === listener) {
+          current.delete(owner);
+        }
         if (current && current.size === 0) {
           requestListenersByKey.delete(key);
         }
@@ -1515,6 +1610,37 @@ function createStandaloneSharedStateService() {
   };
 }
 
+// src/services/tenant.ts
+function createStandaloneTenantService(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = {
+    tenantId: options.tenantId ?? "dev-tenant",
+    tenantSlug: options.tenantSlug ?? "dev"
+  };
+  function emit() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  return {
+    getSnapshot: () => ({ ...snapshot }),
+    setTenant: (tenantId, tenantSlug) => {
+      if (tenantId === snapshot.tenantId && tenantSlug === snapshot.tenantSlug) {
+        return { ...snapshot };
+      }
+      snapshot = { tenantId, tenantSlug };
+      emit();
+      return { ...snapshot };
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
 // src/services/user.ts
 function createStandaloneUserService(seedUser) {
   const listeners = /* @__PURE__ */ new Set();
@@ -1579,7 +1705,7 @@ function createStandaloneUserService(seedUser) {
 }
 
 // src/initStandaloneServices.ts
-function initStandaloneServices(options = {}) {
+function createTestServices(options = {}) {
   const {
     apiBase = "http://localhost:4000",
     lang = "vi",
@@ -1587,25 +1713,31 @@ function initStandaloneServices(options = {}) {
     observability: observabilityConfig = {},
     observabilityOptions,
     realtime: realtimeOptions,
-    customize,
-    registerMode = "if-missing"
+    navigationPath = "/standalone",
+    featureFlags = {},
+    runtimeConfig = {},
+    tenant,
+    appSettings
   } = options;
   const userService = createStandaloneUserService(user ?? null);
   const notificationService = createStandaloneNotificationService();
   const requestContext = createRequestContextService();
-  const services = {
+  const tenantService = createStandaloneTenantService(tenant);
+  const appSettingsService = createStandaloneAppSettingsService(appSettings);
+  return {
     i18n: createStandaloneI18nService(lang),
     userService,
     apiClient: createStandaloneApiClient({
       apiBase,
-      userService,
+      getUserService: () => getService(TOKENS.userService) ?? userService,
       notificationService,
-      requestContext
+      requestContext,
+      tenantService
     }),
-    navigation: createStandaloneNavigationService("/standalone"),
+    navigation: createStandaloneNavigationService(navigationPath),
     configService: createStandaloneConfigService(
-      { [FEATURE_FLAGS2.uiExperimental]: true },
-      { envName: "standalone", apiBase }
+      { [FEATURE_FLAGS2.uiExperimental]: true, ...featureFlags },
+      { envName: runtimeConfig.envName ?? "standalone", apiBase: runtimeConfig.apiBase ?? apiBase }
     ),
     permissionService: createStandalonePermissionService(),
     sharedState: createStandaloneSharedStateService(),
@@ -1620,8 +1752,14 @@ function initStandaloneServices(options = {}) {
       getTraceContext: () => requestContext.getSnapshot()
     }),
     notification: notificationService,
-    analytics: createStandaloneAnalyticsService()
+    analytics: createStandaloneAnalyticsService(),
+    tenantService,
+    appSettingsService
   };
+}
+function initStandaloneServices(options = {}) {
+  const { customize, registerMode = "if-missing" } = options;
+  const services = createTestServices(options);
   customize?.(services);
   services.sharedState.ensureKey(SHARED_STATE_KEYS.x, "host", 0);
   services.sharedState.subscribeRequests(SHARED_STATE_KEYS.x, "host", (request) => {
@@ -1633,42 +1771,32 @@ function initStandaloneServices(options = {}) {
       data: { nextValue: request.nextValue, reason: request.reason ?? "" }
     });
   });
-  if (registerMode === "always" || !getService(TOKENS.i18n)) {
-    registerService(TOKENS.i18n, services.i18n);
-  }
-  if (registerMode === "always" || !getService(TOKENS.userService)) {
-    registerService(TOKENS.userService, services.userService);
-  }
-  if (registerMode === "always" || !getService(TOKENS.apiClient)) {
-    registerService(TOKENS.apiClient, services.apiClient);
-  }
-  if (registerMode === "always" || !getService(TOKENS.navigation)) {
-    registerService(TOKENS.navigation, services.navigation);
-  }
-  if (registerMode === "always" || !getService(TOKENS.configService)) {
-    registerService(TOKENS.configService, services.configService);
-  }
-  if (registerMode === "always" || !getService(TOKENS.permissionService)) {
-    registerService(TOKENS.permissionService, services.permissionService);
-  }
-  if (registerMode === "always" || !getService(TOKENS.sharedState)) {
-    registerService(TOKENS.sharedState, services.sharedState);
-  }
-  if (registerMode === "always" || !getService(TOKENS.requestContext)) {
-    registerService(TOKENS.requestContext, services.requestContext);
-  }
-  if (registerMode === "always" || !getService(TOKENS.realtime)) {
-    registerService(TOKENS.realtime, services.realtime);
-  }
-  if (registerMode === "always" || !getService(TOKENS.observability)) {
-    registerService(TOKENS.observability, services.observability);
-  }
-  if (registerMode === "always" || !getService(TOKENS.notification)) {
-    registerService(TOKENS.notification, services.notification);
-  }
-  if (registerMode === "always" || !getService(TOKENS.analytics)) {
-    registerService(TOKENS.analytics, services.analytics);
-  }
+  const tokenServiceMap = [
+    [TOKENS.i18n, services.i18n],
+    [TOKENS.userService, services.userService],
+    [TOKENS.apiClient, services.apiClient],
+    [TOKENS.navigation, services.navigation],
+    [TOKENS.configService, services.configService],
+    [TOKENS.permissionService, services.permissionService],
+    [TOKENS.sharedState, services.sharedState],
+    [TOKENS.requestContext, services.requestContext],
+    [TOKENS.realtime, services.realtime],
+    [TOKENS.observability, services.observability],
+    [TOKENS.notification, services.notification],
+    [TOKENS.analytics, services.analytics],
+    [TOKENS.tenantService, services.tenantService],
+    [TOKENS.appSettingsService, services.appSettingsService]
+  ];
+  for (const [token, service] of tokenServiceMap) {
+    if (registerMode === "always" || !getService(token)) {
+      registerService(token, service);
+    }
+  }
+}
+function createDevPreset(defaults) {
+  return (overrides) => {
+    initStandaloneServices({ ...defaults, ...overrides });
+  };
 }
 
 // src/services/apiErrorMapper.ts
@@ -2074,6 +2202,8 @@ function createReactRouterNavigationAdapter(options = {}) {
     syncFromRouter: (location, action, capabilities) => {
       const normalizedLocation = normalizeLocation(location);
       const runtimeIndex = capabilities?.historyIndex ?? resolveWindowHistoryIndex();
+      let canGoBack = capabilities?.canGoBack;
+      let canGoForward = capabilities?.canGoForward;
       if (typeof runtimeIndex === "number" && Number.isInteger(runtimeIndex)) {
         currentIndex = runtimeIndex;
         if (runtimeIndex > maxIndex) {
@@ -2082,11 +2212,13 @@ function createReactRouterNavigationAdapter(options = {}) {
       } else if (action === "PUSH") {
         currentIndex += 1;
         maxIndex = currentIndex;
-      } else if (action === "POP" && currentIndex > 0) {
-        currentIndex -= 1;
+      } else if (action === "POP") {
+        const hasHistoryContext = snapshot.canGoBack || snapshot.canGoForward;
+        canGoBack ??= hasHistoryContext;
+        canGoForward ??= hasHistoryContext;
       }
-      const canGoBack = capabilities?.canGoBack ?? currentIndex > 0;
-      const canGoForward = capabilities?.canGoForward ?? currentIndex < maxIndex;
+      canGoBack ??= currentIndex > 0;
+      canGoForward ??= currentIndex < maxIndex;
       setSnapshot({
         action,
         location: normalizedLocation,
@@ -2150,13 +2282,17 @@ function hasSnapshotChanged(previous, nextValue) {
 }
 export {
   ApiError,
+  createDevPreset,
   createMsalUserService,
   createReactRouterNavigationAdapter,
   createRequestContextService,
   createStandaloneApiClient,
+  createStandaloneAppSettingsService,
   createStandaloneI18nService,
   createStandaloneRealtimeService,
+  createStandaloneTenantService,
   createStandaloneUserService,
+  createTestServices,
   initStandaloneServices,
   isApiError,
   mapApiErrorToUiError

package/package.json

@@ -1,45 +1,45 @@
-{
-  "name": "ptech-shell-dev",
-   "version": "1.6.7",
-  "description": "Standalone/mock shell service implementations for Module Federation apps.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean",
-    "dev": "tsup src/index.ts --format esm --dts --out-dir dist --watch",
-    "test": "npm run build && node --test tests/*.test.mjs",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "ptech-shell-sdk": "^1.6.5"
-  },
-  "peerDependencies": {
-    "react": ">=18"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.13 ",
-    "react": "^19.2.4",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
-  },
-  "keywords": [
-    "micro-frontend",
-    "module-federation",
-    "shell",
-    "standalone",
-    "mock"
-  ],
-  "license": "MIT"
-}
+{
+  "name": "ptech-shell-dev",
+  "version": "1.8.0",
+  "description": "Standalone/mock shell service implementations for Module Federation apps.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean",
+    "dev": "tsup src/index.ts --format esm --dts --out-dir dist --watch",
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ptech-shell-sdk": "^1.8.0"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.13",
+    "react": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "micro-frontend",
+    "module-federation",
+    "shell",
+    "standalone",
+    "mock"
+  ],
+  "license": "MIT"
+}