ptech-shell-dev 0.1.0 → 1.6.3

package/dist/index.js

@@ -31,16 +31,607 @@ function createStandaloneAnalyticsService() {
 }
 
 // src/services/apiClient.ts
-function createStandaloneApiClient(apiBase) {
+var ApiError = class _ApiError extends Error {
+  status;
+  code;
+  traceId;
+  correlationId;
+  isNetworkError;
+  isAuthError;
+  isTimeoutError;
+  validationErrors;
+  cause;
+  constructor(details, cause) {
+    super(details.message);
+    this.name = "ApiError";
+    this.status = details.status;
+    this.code = details.code;
+    this.traceId = details.traceId;
+    this.correlationId = details.correlationId;
+    this.isNetworkError = details.isNetworkError;
+    this.isAuthError = details.isAuthError;
+    this.isTimeoutError = details.isTimeoutError;
+    this.validationErrors = details.validationErrors;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _ApiError.prototype);
+  }
+};
+var DEFAULT_TIMEOUT_MS = 2e4;
+var DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 2,
+  baseDelayMs: 250,
+  maxDelayMs: 2e3,
+  retryOnStatuses: [429, 503]
+};
+var TRACE_HEADER = "traceparent";
+var CORRELATION_HEADER = "x-correlation-id";
+var CORRELATION_HEADERS = ["x-correlation-id", "x-request-id"];
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function isApiError(value) {
+  return value instanceof ApiError;
+}
+function normalizeApiBase(apiBase) {
+  return apiBase.replace(/\/+$/, "");
+}
+function isAbsoluteUrl(input) {
+  return /^(?:[a-z][a-z\d+\-.]*:)?\/\//i.test(input);
+}
+function resolveUrl(apiBase, input) {
+  if (isAbsoluteUrl(input) || apiBase.length === 0) {
+    return input;
+  }
+  if (input.startsWith("/")) {
+    return `${apiBase}${input}`;
+  }
+  return `${apiBase}/${input}`;
+}
+function generateHex(length) {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(length / 2);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  let value = "";
+  for (let i = 0; i < length; i += 1) {
+    value += Math.floor(Math.random() * 16).toString(16);
+  }
+  return value;
+}
+function createTraceparent() {
+  const traceId = generateHex(32);
+  const parentId = generateHex(16);
+  return `00-${traceId}-${parentId}-01`;
+}
+function normalizeValidationErrors(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const normalized = {};
+  for (const [key, fieldErrors] of Object.entries(value)) {
+    if (!Array.isArray(fieldErrors)) {
+      continue;
+    }
+    const messages = fieldErrors.filter((fieldError) => typeof fieldError === "string");
+    if (messages.length > 0) {
+      normalized[key] = messages;
+    }
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeMethod(method) {
+  const normalized = method?.toUpperCase();
+  switch (normalized) {
+    case "GET":
+    case "POST":
+    case "PUT":
+    case "PATCH":
+    case "DELETE":
+    case "HEAD":
+    case "OPTIONS":
+      return normalized;
+    default:
+      return "GET";
+  }
+}
+function resolveBody(body, headers) {
+  if (body === void 0 || body === null) {
+    return void 0;
+  }
+  if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof URLSearchParams || typeof body === "string") {
+    return body;
+  }
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  return JSON.stringify(body);
+}
+function isJsonContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  const normalized = contentType.toLowerCase();
+  return normalized.includes("application/json") || normalized.includes("+json");
+}
+async function parseBody(response, responseType) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  if (responseType === "arrayBuffer") {
+    return response.arrayBuffer();
+  }
+  if (responseType === "blob") {
+    return response.blob();
+  }
+  const text = await response.text();
+  if (!text) {
+    return void 0;
+  }
+  if (responseType === "text") {
+    return text;
+  }
+  const shouldParseJson = responseType === "json" || isJsonContentType(response.headers.get("content-type"));
+  if (!shouldParseJson) {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    if (responseType === "json") {
+      throw error;
+    }
+    return text;
+  }
+}
+function toProblemDetails(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  return payload;
+}
+function resolveTraceId(problem, response) {
+  if (typeof problem?.traceId === "string" && problem.traceId.length > 0) {
+    return problem.traceId;
+  }
+  if (typeof problem?.extensions?.traceId === "string" && problem.extensions.traceId.length > 0) {
+    return problem.extensions.traceId;
+  }
+  const traceparent = response.headers.get(TRACE_HEADER);
+  if (traceparent) {
+    const parts = traceparent.split("-");
+    if (parts.length >= 4 && parts[1]) {
+      return parts[1];
+    }
+    return traceparent;
+  }
+  for (const headerName of CORRELATION_HEADERS) {
+    const value = response.headers.get(headerName);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveErrorCode(problem) {
+  if (typeof problem?.code === "string" && problem.code.length > 0) {
+    return problem.code;
+  }
+  if (typeof problem?.extensions?.code === "string" && problem.extensions.code.length > 0) {
+    return problem.extensions.code;
+  }
+  return void 0;
+}
+function resolveCorrelationId(problem, response) {
+  if (typeof problem?.extensions?.correlationId === "string" && problem.extensions.correlationId.length > 0) {
+    return problem.extensions.correlationId;
+  }
+  for (const headerName of CORRELATION_HEADERS) {
+    const value = response.headers.get(headerName);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveHttpErrorMessage(explicitMessage, problem, payload, status) {
+  if (explicitMessage) {
+    return explicitMessage;
+  }
+  if (typeof problem?.detail === "string" && problem.detail.length > 0) {
+    return problem.detail;
+  }
+  if (typeof problem?.title === "string" && problem.title.length > 0) {
+    return problem.title;
+  }
+  if (typeof payload === "string" && payload.length > 0) {
+    return payload;
+  }
+  return `Request failed with status ${status}`;
+}
+function createHttpError(options, response, payload, problem) {
+  const correlationId = resolveCorrelationId(problem, response);
+  const traceId = resolveTraceId(problem, response) ?? correlationId;
+  return new ApiError({
+    status: response.status,
+    code: resolveErrorCode(problem),
+    traceId,
+    correlationId,
+    message: resolveHttpErrorMessage(options.errorMessage, problem, payload, response.status),
+    isNetworkError: false,
+    isAuthError: response.status === 401 || response.status === 403,
+    isTimeoutError: false,
+    validationErrors: normalizeValidationErrors(problem?.errors)
+  });
+}
+function createNetworkError(options, cause, details) {
+  const message = options.errorMessage ?? (details.isTimeoutError ? "Request timeout" : "Network error");
+  const code = details.isAbortedByCaller ? "aborted" : details.isTimeoutError ? "timeout" : "network_error";
+  return new ApiError(
+    {
+      code,
+      message,
+      isNetworkError: true,
+      isAuthError: false,
+      isTimeoutError: details.isTimeoutError
+    },
+    cause
+  );
+}
+function createInvalidResponseError(options, response, cause) {
+  return new ApiError(
+    {
+      status: response.status,
+      code: "invalid_response",
+      traceId: resolveTraceId(null, response),
+      message: options.errorMessage ?? "Invalid response payload",
+      isNetworkError: false,
+      isAuthError: response.status === 401 || response.status === 403,
+      isTimeoutError: false
+    },
+    cause
+  );
+}
+function shouldPushPostErrorNotification(method, error) {
+  return method === "POST" && error.code !== "aborted";
+}
+function resolvePostErrorNotificationMessage(error) {
+  if (error.traceId) {
+    return `${error.message} (traceId: ${error.traceId})`;
+  }
+  return error.message;
+}
+function pushPostErrorNotification(method, requestOptions, error, options) {
+  if (!shouldPushPostErrorNotification(method, error)) {
+    return;
+  }
+  const notificationService = options.getNotificationService?.();
+  if (!notificationService) {
+    return;
+  }
+  try {
+    notificationService.push({
+      level: "error",
+      title: "POST request failed",
+      message: resolvePostErrorNotificationMessage(error),
+      source: `standalone.apiClient:${requestOptions.url}`,
+      ttlMs: 5e3
+    });
+  } catch {
+  }
+}
+function isAbortError(error) {
+  return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function normalizeRetryOptions(input, defaultRetryOptions) {
+  if (input === false) {
+    return null;
+  }
+  const mergedInput = input ?? defaultRetryOptions;
+  if (mergedInput === false) {
+    return null;
+  }
+  const maxAttempts = Math.max(
+    1,
+    Math.floor(mergedInput.maxAttempts ?? DEFAULT_RETRY_OPTIONS.maxAttempts)
+  );
+  const baseDelayMs = Math.max(
+    0,
+    Math.floor(mergedInput.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs)
+  );
+  const maxDelayMs = Math.max(
+    baseDelayMs,
+    Math.floor(mergedInput.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs)
+  );
+  const retryOnStatuses = new Set(
+    (mergedInput.retryOnStatuses ?? DEFAULT_RETRY_OPTIONS.retryOnStatuses).filter((status) => Number.isInteger(status) && status >= 100 && status <= 599)
+  );
   return {
-    fetch: async (path, init) => {
-      const url = path.startsWith("http") ? path : `${apiBase}${path.startsWith("/") ? "" : "/"}${path}`;
-      const headers = new Headers(init?.headers);
-      if (!headers.has("Authorization")) {
-        headers.set("Authorization", "Bearer dev-token");
+    maxAttempts,
+    baseDelayMs,
+    maxDelayMs,
+    retryOnStatuses
+  };
+}
+function shouldRetryResponse(response, retry) {
+  return retry.retryOnStatuses.has(response.status);
+}
+function shouldRetryError(error) {
+  return error.isNetworkError && error.code !== "aborted";
+}
+function computeRetryDelayMs(attempt, retry) {
+  const exponent = Math.max(0, attempt - 1);
+  const rawDelay = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** exponent);
+  const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(rawDelay * 0.2)));
+  return rawDelay + jitter;
+}
+async function sleep(delayMs, signal) {
+  if (delayMs <= 0) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
       }
-      return fetch(url, { ...init, headers });
+      resolve();
+    }, delayMs);
+    if (!signal) {
+      return;
     }
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal.removeEventListener("abort", onAbort);
+      if (typeof DOMException !== "undefined") {
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      const abortError = new Error("Aborted");
+      abortError.name = "AbortError";
+      reject(abortError);
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function resolveCreateOptions(input) {
+  if (typeof input === "string") {
+    return {
+      apiBase: normalizeApiBase(input),
+      defaultAuthScopes: [],
+      defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+      defaultRetries: DEFAULT_RETRY_OPTIONS
+    };
+  }
+  return {
+    apiBase: normalizeApiBase(input.apiBase),
+    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),
+    defaultAuthScopes: input.defaultAuthScopes ?? [],
+    defaultTimeoutMs: input.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+    defaultRetries: input.defaultRetries ?? DEFAULT_RETRY_OPTIONS
+  };
+}
+function applyRequestContextHeaders(headers, options) {
+  const contextService = options.getRequestContext?.();
+  if (!contextService) {
+    if (!headers.has(TRACE_HEADER)) {
+      headers.set(TRACE_HEADER, createTraceparent());
+    }
+    return;
+  }
+  const context = contextService.getSnapshot();
+  if (!headers.has(TRACE_HEADER)) {
+    headers.set(TRACE_HEADER, `00-${context.traceId}-${generateHex(16)}-01`);
+  }
+  if (!headers.has(CORRELATION_HEADER)) {
+    headers.set(CORRELATION_HEADER, context.correlationId);
+  }
+}
+function syncResponseContext(response, options) {
+  const contextService = options.getRequestContext?.();
+  if (!contextService) {
+    return;
+  }
+  const traceparent = response.headers.get(TRACE_HEADER);
+  const correlationId = response.headers.get(CORRELATION_HEADER) ?? response.headers.get("x-request-id");
+  const traceIdFromTraceparent = traceparent?.split("-")?.[1];
+  contextService.update({
+    traceId: traceIdFromTraceparent,
+    correlationId: correlationId ?? void 0
+  });
+}
+async function applyAuthorization(headers, requestOptions, options) {
+  if (requestOptions.auth === false || headers.has("Authorization")) {
+    return;
+  }
+  const userService = options.getUserService?.();
+  const acquireAccessToken = userService?.acquireAccessToken;
+  if (!acquireAccessToken) {
+    return;
+  }
+  const scopes = requestOptions.authScopes ?? options.defaultAuthScopes;
+  try {
+    const token = await acquireAccessToken({ scopes });
+    if (!token?.token) {
+      return;
+    }
+    const tokenValue = token.token.trim();
+    if (!token.tokenType && tokenValue.includes(" ")) {
+      headers.set("Authorization", tokenValue);
+      return;
+    }
+    const tokenType = token.tokenType?.trim() || "Bearer";
+    headers.set("Authorization", `${tokenType} ${tokenValue}`);
+  } catch {
+  }
+}
+async function fetchWithTimeout(url, init, timeoutMs, signal, requestOptions) {
+  const controller = new AbortController();
+  let timeoutId;
+  let isTimeoutError = false;
+  let abortListener;
+  if (signal) {
+    if (signal.aborted) {
+      controller.abort();
+    } else {
+      const onAbort = () => controller.abort();
+      signal.addEventListener("abort", onAbort, { once: true });
+      abortListener = () => signal.removeEventListener("abort", onAbort);
+    }
+  }
+  if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+    timeoutId = setTimeout(() => {
+      isTimeoutError = true;
+      controller.abort();
+    }, timeoutMs);
+  }
+  try {
+    return await fetch(url, {
+      ...init,
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (isApiError(error)) {
+      throw error;
+    }
+    if (isAbortError(error)) {
+      throw createNetworkError(requestOptions, error, {
+        isTimeoutError,
+        isAbortedByCaller: Boolean(signal?.aborted) && !isTimeoutError
+      });
+    }
+    throw createNetworkError(requestOptions, error, {
+      isTimeoutError: false,
+      isAbortedByCaller: false
+    });
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    abortListener?.();
+  }
+}
+async function executeRaw(requestOptions, options) {
+  const method = normalizeMethod(requestOptions.method);
+  const shouldUseRetry = IDEMPOTENT_METHODS.has(method);
+  const retry = normalizeRetryOptions(requestOptions.retries, options.defaultRetries);
+  const maxAttempts = shouldUseRetry && retry ? retry.maxAttempts : 1;
+  const timeoutMs = requestOptions.timeoutMs ?? options.defaultTimeoutMs;
+  const headers = new Headers(requestOptions.headers);
+  applyRequestContextHeaders(headers, options);
+  await applyAuthorization(headers, requestOptions, options);
+  const url = resolveUrl(options.apiBase, requestOptions.url);
+  const body = resolveBody(requestOptions.body, headers);
+  const baseInit = {
+    method,
+    headers,
+    body
+  };
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        baseInit,
+        timeoutMs,
+        requestOptions.signal,
+        requestOptions
+      );
+      syncResponseContext(response, options);
+      if (retry && shouldUseRetry && attempt < maxAttempts && shouldRetryResponse(response, retry)) {
+        const delayMs = computeRetryDelayMs(attempt, retry);
+        await sleep(delayMs, requestOptions.signal);
+        continue;
+      }
+      return response;
+    } catch (error) {
+      const normalizedError = isApiError(error) ? error : isAbortError(error) ? createNetworkError(requestOptions, error, {
+        isTimeoutError: false,
+        isAbortedByCaller: true
+      }) : createNetworkError(requestOptions, error, {
+        isTimeoutError: false,
+        isAbortedByCaller: false
+      });
+      if (retry && shouldUseRetry && attempt < maxAttempts && shouldRetryError(normalizedError)) {
+        const delayMs = computeRetryDelayMs(attempt, retry);
+        await sleep(delayMs, requestOptions.signal);
+        continue;
+      }
+      throw normalizedError;
+    }
+  }
+  throw createNetworkError(requestOptions, null, {
+    isTimeoutError: false,
+    isAbortedByCaller: false
+  });
+}
+async function executeParsed(requestOptions, options) {
+  const method = normalizeMethod(requestOptions.method);
+  try {
+    const response = await executeRaw(requestOptions, options);
+    const responseType = requestOptions.responseType ?? "auto";
+    let payload;
+    try {
+      payload = await parseBody(response, responseType);
+    } catch (error) {
+      throw createInvalidResponseError(requestOptions, response, error);
+    }
+    if (!response.ok) {
+      const problem = toProblemDetails(payload);
+      throw createHttpError(requestOptions, response, payload, problem);
+    }
+    return payload;
+  } catch (error) {
+    const normalizedError = isApiError(error) ? error : isAbortError(error) ? createNetworkError(requestOptions, error, {
+      isTimeoutError: false,
+      isAbortedByCaller: true
+    }) : createNetworkError(requestOptions, error, {
+      isTimeoutError: false,
+      isAbortedByCaller: false
+    });
+    pushPostErrorNotification(method, requestOptions, normalizedError, options);
+    throw normalizedError;
+  }
+}
+function createStandaloneApiClient(options) {
+  const resolvedOptions = resolveCreateOptions(options);
+  return {
+    fetch: async (input, init) => {
+      const headers = new Headers(init?.headers);
+      applyRequestContextHeaders(headers, resolvedOptions);
+      await applyAuthorization(
+        headers,
+        {
+          url: input,
+          method: normalizeMethod(init?.method),
+          auth: true
+        },
+        resolvedOptions
+      );
+      const url = resolveUrl(resolvedOptions.apiBase, input);
+      const response = await fetch(url, {
+        ...init,
+        headers
+      });
+      syncResponseContext(response, resolvedOptions);
+      return response;
+    },
+    request: (requestOptions) => executeParsed(
+      {
+        ...requestOptions,
+        method: normalizeMethod(requestOptions.method)
+      },
+      resolvedOptions
+    ),
+    requestRaw: (requestOptions) => executeRaw(
+      {
+        ...requestOptions,
+        method: normalizeMethod(requestOptions.method)
+      },
+      resolvedOptions
+    )
   };
 }
 
@@ -156,21 +747,83 @@ function createStandaloneI18nService(initialLang) {
 }
 
 // src/services/navigation.ts
+var NAVIGATION_BASE_URL = "https://mfe.navigation.local";
 function createStandaloneNavigationService(initialPath = "/standalone") {
   const listeners = /* @__PURE__ */ new Set();
-  let currentPath = initialPath;
+  const history = [createInitialLocation(initialPath)];
+  let currentIndex = 0;
+  let currentAction = "POP";
   function emitChange() {
     for (const listener of listeners) {
       listener();
     }
   }
+  function getCurrentLocation() {
+    return history[currentIndex];
+  }
+  function createSnapshot2() {
+    const location = getCurrentLocation();
+    return {
+      action: currentAction,
+      location: { ...location },
+      canGoBack: currentIndex > 0,
+      canGoForward: currentIndex < history.length - 1
+    };
+  }
+  function createHref(to) {
+    return toToHref(to, getCurrentLocation());
+  }
   return {
-    getPath: () => currentPath,
-    navigate: (path) => {
-      if (path === currentPath) {
+    getSnapshot: () => createSnapshot2(),
+    getPath: () => getCurrentLocation().pathname,
+    createHref,
+    navigate: (to, options) => {
+      if (typeof to === "number") {
+        const nextIndex = clamp(currentIndex + to, 0, history.length - 1);
+        if (nextIndex === currentIndex) {
+          return;
+        }
+        currentIndex = nextIndex;
+        currentAction = "POP";
+        emitChange();
+        return;
+      }
+      const current = getCurrentLocation();
+      const next = toLocation(to, current, options?.state);
+      const replace = options?.replace === true;
+      if (replace) {
+        if (isSameLocation(current, next)) {
+          return;
+        }
+        history[currentIndex] = next;
+        currentAction = "REPLACE";
+        emitChange();
         return;
       }
-      currentPath = path;
+      if (isSameLocation(current, next)) {
+        return;
+      }
+      history.splice(currentIndex + 1, history.length - currentIndex - 1, next);
+      currentIndex += 1;
+      currentAction = "PUSH";
+      emitChange();
+    },
+    back: () => {
+      const nextIndex = currentIndex - 1;
+      if (nextIndex < 0) {
+        return;
+      }
+      currentIndex = nextIndex;
+      currentAction = "POP";
+      emitChange();
+    },
+    forward: () => {
+      const nextIndex = currentIndex + 1;
+      if (nextIndex >= history.length) {
+        return;
+      }
+      currentIndex = nextIndex;
+      currentAction = "POP";
       emitChange();
     },
     subscribe: (listener) => {
@@ -179,6 +832,66 @@ function createStandaloneNavigationService(initialPath = "/standalone") {
     }
   };
 }
+function createInitialLocation(initialPath) {
+  const url = new URL(initialPath, `${NAVIGATION_BASE_URL}/`);
+  return {
+    pathname: url.pathname || "/",
+    search: url.search,
+    hash: url.hash,
+    state: void 0,
+    key: createLocationKey()
+  };
+}
+function createLocationKey() {
+  return Math.random().toString(36).slice(2, 10);
+}
+function normalizeSearch(search) {
+  if (!search) {
+    return "";
+  }
+  return search.startsWith("?") ? search : `?${search}`;
+}
+function normalizeHash(hash) {
+  if (!hash) {
+    return "";
+  }
+  return hash.startsWith("#") ? hash : `#${hash}`;
+}
+function toToHref(to, current) {
+  if (typeof to === "string") {
+    return to;
+  }
+  const pathname = to.pathname ?? current.pathname;
+  const search = to.search !== void 0 ? normalizeSearch(to.search) : current.search;
+  const hash = to.hash !== void 0 ? normalizeHash(to.hash) : current.hash;
+  return `${pathname || "/"}${search}${hash}`;
+}
+function toLocation(to, current, state) {
+  if (typeof to === "string") {
+    const currentHref = `${current.pathname}${current.search}${current.hash}`;
+    const resolved = new URL(to, `${NAVIGATION_BASE_URL}${currentHref || "/"}`);
+    return {
+      pathname: resolved.pathname || "/",
+      search: resolved.search,
+      hash: resolved.hash,
+      state,
+      key: createLocationKey()
+    };
+  }
+  return {
+    pathname: to.pathname ?? current.pathname,
+    search: to.search !== void 0 ? normalizeSearch(to.search) : current.search,
+    hash: to.hash !== void 0 ? normalizeHash(to.hash) : current.hash,
+    state,
+    key: createLocationKey()
+  };
+}
+function isSameLocation(left, right) {
+  return left.pathname === right.pathname && left.search === right.search && left.hash === right.hash && Object.is(left.state, right.state);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
 
 // src/services/notification.ts
 function createStandaloneNotificationService() {
@@ -209,6 +922,7 @@ function createStandaloneNotificationService() {
       const item = {
         id,
         level: input.level,
+        title: input.title,
         message: input.message,
         source: input.source,
         createdAt: Date.now()
@@ -232,16 +946,77 @@ function createStandaloneNotificationService() {
 
 // src/services/observability.ts
 var MAX_ENTRIES = 100;
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+var DEFAULT_ENABLED_LEVELS = {
+  debug: true,
+  info: true,
+  warn: true,
+  error: true
+};
 var LOG_METHOD = {
   debug: "log",
   info: "info",
   warn: "warn",
   error: "error"
 };
-function createStandaloneObservabilityService() {
+var LOG_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function isProductionEnv() {
+  const nodeProcess = globalThis.process;
+  if (nodeProcess?.env?.NODE_ENV === "production") {
+    return true;
+  }
+  const bundlerEnv = import.meta.env;
+  return bundlerEnv?.PROD === true || bundlerEnv?.MODE === "production";
+}
+function cloneConfig(config) {
+  return {
+    minLevel: config.minLevel,
+    enabledLevels: { ...config.enabledLevels }
+  };
+}
+function createInitialConfig(configPatch) {
+  return {
+    minLevel: configPatch.minLevel ?? (isProductionEnv() ? "error" : "debug"),
+    enabledLevels: {
+      ...DEFAULT_ENABLED_LEVELS,
+      ...configPatch.enabledLevels ?? {}
+    }
+  };
+}
+function shouldRecordEntry(level, config) {
+  if (!config.enabledLevels[level]) {
+    return false;
+  }
+  return LOG_PRIORITY[level] >= LOG_PRIORITY[config.minLevel];
+}
+function applyConfigPatch(config, patch) {
+  return {
+    minLevel: patch.minLevel ?? config.minLevel,
+    enabledLevels: patch.enabledLevels ? { ...config.enabledLevels, ...patch.enabledLevels } : { ...config.enabledLevels }
+  };
+}
+function hasConfigChanged(current, next) {
+  if (current.minLevel !== next.minLevel) {
+    return true;
+  }
+  for (const level of LOG_LEVELS) {
+    if (current.enabledLevels[level] !== next.enabledLevels[level]) {
+      return true;
+    }
+  }
+  return false;
+}
+function createStandaloneObservabilityService(configPatch = {}, options = {}) {
   const listeners = /* @__PURE__ */ new Set();
   const entries = [];
   let nextId = 1;
+  let config = createInitialConfig(configPatch);
+  const redact = options.redact ?? ((data) => data);
   function emitChange() {
     for (const listener of listeners) {
       listener();
@@ -249,6 +1024,9 @@ function createStandaloneObservabilityService() {
   }
   return {
     log: (entry) => {
+      if (!shouldRecordEntry(entry.level, config)) {
+        return;
+      }
       const nextEntry = {
         ...entry,
         id: nextId,
@@ -261,12 +1039,35 @@ function createStandaloneObservabilityService() {
       }
       const method = LOG_METHOD[nextEntry.level];
       console[method](`[${nextEntry.source}] ${nextEntry.message}`, nextEntry.data ?? "");
+      if (options.telemetrySink) {
+        const traceContext = options.getTraceContext?.();
+        void Promise.resolve(
+          options.telemetrySink.track({
+            level: nextEntry.level,
+            source: nextEntry.source,
+            message: nextEntry.message,
+            timestamp: nextEntry.timestamp,
+            traceId: traceContext?.traceId,
+            correlationId: traceContext?.correlationId,
+            data: redact(nextEntry.data)
+          })
+        ).catch(() => void 0);
+      }
       emitChange();
     },
     getEntries: () => [...entries],
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);
+    },
+    getConfig: () => cloneConfig(config),
+    updateConfig: (patch) => {
+      const nextConfig = applyConfigPatch(config, patch);
+      if (!hasConfigChanged(config, nextConfig)) {
+        return;
+      }
+      config = nextConfig;
+      emitChange();
     }
   };
 }
@@ -290,6 +1091,315 @@ function createStandalonePermissionService(initialPermissions = DEFAULT_PERMISSI
   };
 }
 
+// src/services/realtime.ts
+var DEFAULT_RECONNECT = {
+  initialDelayMs: 800,
+  maxDelayMs: 15e3,
+  maxAttempts: Number.POSITIVE_INFINITY
+};
+function normalizeReconnectOptions(input) {
+  if (!input) {
+    return { ...DEFAULT_RECONNECT };
+  }
+  return {
+    initialDelayMs: Math.max(0, Math.floor(input.initialDelayMs ?? DEFAULT_RECONNECT.initialDelayMs)),
+    maxDelayMs: Math.max(
+      Math.floor(input.initialDelayMs ?? DEFAULT_RECONNECT.initialDelayMs),
+      Math.floor(input.maxDelayMs ?? DEFAULT_RECONNECT.maxDelayMs)
+    ),
+    maxAttempts: input.maxAttempts === void 0 ? DEFAULT_RECONNECT.maxAttempts : Math.max(1, Math.floor(input.maxAttempts))
+  };
+}
+function computeReconnectDelayMs(attempt, reconnect) {
+  const exponent = Math.max(0, attempt - 1);
+  const raw = Math.min(reconnect.maxDelayMs, reconnect.initialDelayMs * 2 ** exponent);
+  const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(raw * 0.2)));
+  return raw + jitter;
+}
+function createNoopTransport() {
+  let messageListener;
+  let disconnectListener;
+  return {
+    start: async () => {
+      messageListener = messageListener;
+      disconnectListener = disconnectListener;
+    },
+    stop: async () => void 0,
+    onMessage: (listener) => {
+      messageListener = listener;
+      return () => {
+        if (messageListener === listener) {
+          messageListener = void 0;
+        }
+      };
+    },
+    onDisconnect: (listener) => {
+      disconnectListener = listener;
+      return () => {
+        if (disconnectListener === listener) {
+          disconnectListener = void 0;
+        }
+      };
+    },
+    send: async () => void 0
+  };
+}
+function resolveTraceContext(requestContext) {
+  if (!requestContext) {
+    return {};
+  }
+  const snapshot = requestContext.getSnapshot();
+  return {
+    traceId: snapshot.traceId,
+    correlationId: snapshot.correlationId
+  };
+}
+function createStandaloneRealtimeService(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Map();
+  const reconnect = normalizeReconnectOptions(options.reconnect);
+  const resolveUserService = options.getUserService ?? (options.userService ? () => options.userService : void 0);
+  const resolveRequestContext = options.getRequestContext ?? (options.requestContext ? () => options.requestContext : void 0);
+  const createTransport = options.createTransport ?? createNoopTransport;
+  let state = "idle";
+  let transport = null;
+  let stopRequested = false;
+  let activeAttempt = 0;
+  let reconnectTimer;
+  let unbindMessage;
+  let unbindDisconnect;
+  let inFlightStart = null;
+  function emitStateChanged() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function setState(next) {
+    if (state === next) {
+      return;
+    }
+    state = next;
+    emitStateChanged();
+  }
+  function clearReconnectTimer() {
+    if (!reconnectTimer) {
+      return;
+    }
+    clearTimeout(reconnectTimer);
+    reconnectTimer = void 0;
+  }
+  function unbindTransportListeners() {
+    unbindMessage?.();
+    unbindMessage = void 0;
+    unbindDisconnect?.();
+    unbindDisconnect = void 0;
+  }
+  function dispatchEnvelope(envelope) {
+    const listenersForEvent = eventListeners.get(envelope.event);
+    if (!listenersForEvent || listenersForEvent.size === 0) {
+      return;
+    }
+    for (const listener of listenersForEvent) {
+      listener(envelope);
+    }
+  }
+  async function resolveAccessToken() {
+    const userService = resolveUserService?.();
+    const acquireAccessToken = userService?.acquireAccessToken;
+    if (!acquireAccessToken) {
+      return void 0;
+    }
+    try {
+      const token = await acquireAccessToken({ scopes: [] });
+      return token?.token;
+    } catch {
+      return void 0;
+    }
+  }
+  function scheduleReconnect() {
+    if (stopRequested) {
+      return;
+    }
+    if (activeAttempt >= reconnect.maxAttempts) {
+      setState("disconnected");
+      return;
+    }
+    activeAttempt += 1;
+    const delayMs = computeReconnectDelayMs(activeAttempt, reconnect);
+    setState("reconnecting");
+    clearReconnectTimer();
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = void 0;
+      void startInternal();
+    }, delayMs);
+  }
+  async function bindTransportListeners(currentTransport) {
+    unbindTransportListeners();
+    unbindMessage = currentTransport.onMessage((incoming) => {
+      const context = resolveTraceContext(resolveRequestContext?.());
+      dispatchEnvelope({
+        event: incoming.event,
+        payload: incoming.payload,
+        receivedAt: incoming.receivedAt || Date.now(),
+        traceId: incoming.traceId ?? context.traceId,
+        correlationId: incoming.correlationId ?? context.correlationId
+      });
+    });
+    if (currentTransport.onDisconnect) {
+      unbindDisconnect = currentTransport.onDisconnect(() => {
+        if (stopRequested) {
+          return;
+        }
+        scheduleReconnect();
+      });
+    }
+  }
+  async function startInternal() {
+    if (inFlightStart) {
+      return inFlightStart;
+    }
+    inFlightStart = (async () => {
+      stopRequested = false;
+      clearReconnectTimer();
+      setState(activeAttempt > 0 ? "reconnecting" : "connecting");
+      const nextTransport = createTransport();
+      const token = await resolveAccessToken();
+      const context = resolveTraceContext(resolveRequestContext?.());
+      try {
+        await nextTransport.start({
+          accessToken: token,
+          traceId: context.traceId,
+          correlationId: context.correlationId
+        });
+        transport = nextTransport;
+        await bindTransportListeners(nextTransport);
+        activeAttempt = 0;
+        setState("connected");
+      } catch {
+        transport = null;
+        unbindTransportListeners();
+        scheduleReconnect();
+      }
+    })();
+    try {
+      await inFlightStart;
+    } finally {
+      inFlightStart = null;
+    }
+  }
+  async function stopInternal() {
+    stopRequested = true;
+    clearReconnectTimer();
+    const current = transport;
+    transport = null;
+    unbindTransportListeners();
+    if (current) {
+      try {
+        await current.stop();
+      } catch {
+      }
+    }
+    activeAttempt = 0;
+    setState("disconnected");
+  }
+  return {
+    start: async () => {
+      if (state === "connected" || state === "connecting" || state === "reconnecting") {
+        return;
+      }
+      await startInternal();
+    },
+    stop: async () => {
+      await stopInternal();
+    },
+    restart: async () => {
+      await stopInternal();
+      await startInternal();
+    },
+    getState: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    on: (event, listener) => {
+      let listenersForEvent = eventListeners.get(event);
+      if (!listenersForEvent) {
+        listenersForEvent = /* @__PURE__ */ new Set();
+        eventListeners.set(event, listenersForEvent);
+      }
+      listenersForEvent.add(listener);
+      return {
+        unsubscribe: () => {
+          const current = eventListeners.get(event);
+          current?.delete(listener);
+          if (current && current.size === 0) {
+            eventListeners.delete(event);
+          }
+        }
+      };
+    },
+    send: async (event, payload) => {
+      if (!transport?.send) {
+        return;
+      }
+      await transport.send(event, payload);
+    }
+  };
+}
+
+// src/services/requestContext.ts
+function generateHex2(length) {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(length / 2);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  let value = "";
+  for (let index = 0; index < length; index += 1) {
+    value += Math.floor(Math.random() * 16).toString(16);
+  }
+  return value;
+}
+function createSnapshot(seed) {
+  return {
+    traceId: seed?.traceId?.trim() || generateHex2(32),
+    correlationId: seed?.correlationId?.trim() || generateHex2(16)
+  };
+}
+function createRequestContextService(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = createSnapshot(options);
+  function emitChange() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  return {
+    getSnapshot: () => ({ ...snapshot }),
+    update: (next) => {
+      const nextSnapshot = createSnapshot({
+        traceId: next.traceId ?? snapshot.traceId,
+        correlationId: next.correlationId ?? snapshot.correlationId
+      });
+      if (nextSnapshot.traceId === snapshot.traceId && nextSnapshot.correlationId === snapshot.correlationId) {
+        return { ...snapshot };
+      }
+      snapshot = nextSnapshot;
+      emitChange();
+      return { ...snapshot };
+    },
+    rotate: () => {
+      snapshot = createSnapshot();
+      emitChange();
+      return { ...snapshot };
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
 // src/services/sharedState.ts
 function createStandaloneSharedStateService() {
   const records = /* @__PURE__ */ new Map();
@@ -406,11 +1516,61 @@ function createStandaloneSharedStateService() {
 }
 
 // src/services/user.ts
-function createStandaloneUserService(user) {
+function createStandaloneUserService(seedUser) {
   const listeners = /* @__PURE__ */ new Set();
-  const currentUser = user;
+  let currentUser = seedUser;
+  function emitChanged() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
   return {
     getSnapshot: () => currentUser,
+    getSession: () => ({
+      state: currentUser ? "authenticated" : "unauthenticated",
+      provider: "mock",
+      account: currentUser ? {
+        homeAccountId: currentUser.id,
+        localAccountId: currentUser.id,
+        tenantId: currentUser.tenantId,
+        username: currentUser.username ?? currentUser.email ?? currentUser.name,
+        name: currentUser.name,
+        idTokenClaims: currentUser.claims
+      } : void 0,
+      idTokenClaims: currentUser?.claims
+    }),
+    acquireAccessToken: async (request) => {
+      if (!currentUser) {
+        return null;
+      }
+      return {
+        token: `standalone-token-${currentUser.id}`,
+        tokenType: "Bearer",
+        scopes: request.scopes,
+        expiresAt: Date.now() + 60 * 60 * 1e3
+      };
+    },
+    login: async (options) => {
+      if (currentUser) {
+        return;
+      }
+      const loginHint = options?.loginHint?.trim();
+      const id = loginHint ? loginHint.toLowerCase() : "dev";
+      currentUser = {
+        id,
+        name: loginHint || "Dev User",
+        username: loginHint || "dev",
+        email: loginHint ? `${loginHint}@example.local` : "dev@example.local"
+      };
+      emitChanged();
+    },
+    logout: async () => {
+      if (!currentUser) {
+        return;
+      }
+      currentUser = null;
+      emitChanged();
+    },
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -424,13 +1584,24 @@ function initStandaloneServices(options = {}) {
     apiBase = "http://localhost:4000",
     lang = "vi",
     user = { id: "dev", name: "Dev User" },
+    observability: observabilityConfig = {},
+    observabilityOptions,
+    realtime: realtimeOptions,
     customize,
     registerMode = "if-missing"
   } = options;
+  const userService = createStandaloneUserService(user ?? null);
+  const notificationService = createStandaloneNotificationService();
+  const requestContext = createRequestContextService();
   const services = {
     i18n: createStandaloneI18nService(lang),
-    userService: createStandaloneUserService(user ?? null),
-    apiClient: createStandaloneApiClient(apiBase),
+    userService,
+    apiClient: createStandaloneApiClient({
+      apiBase,
+      userService,
+      notificationService,
+      requestContext
+    }),
     navigation: createStandaloneNavigationService("/standalone"),
     configService: createStandaloneConfigService(
       { [FEATURE_FLAGS2.uiExperimental]: true },
@@ -438,8 +1609,17 @@ function initStandaloneServices(options = {}) {
     ),
     permissionService: createStandalonePermissionService(),
     sharedState: createStandaloneSharedStateService(),
-    observability: createStandaloneObservabilityService(),
-    notification: createStandaloneNotificationService(),
+    requestContext,
+    realtime: createStandaloneRealtimeService({
+      ...realtimeOptions,
+      userService,
+      requestContext
+    }),
+    observability: createStandaloneObservabilityService(observabilityConfig, {
+      ...observabilityOptions,
+      getTraceContext: () => requestContext.getSnapshot()
+    }),
+    notification: notificationService,
     analytics: createStandaloneAnalyticsService()
   };
   customize?.(services);
@@ -474,6 +1654,12 @@ function initStandaloneServices(options = {}) {
   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);
   }
@@ -484,9 +1670,464 @@ function initStandaloneServices(options = {}) {
     registerService(TOKENS.analytics, services.analytics);
   }
 }
+
+// src/services/apiErrorMapper.ts
+function isValidationError(error) {
+  return Boolean(error.validationErrors && Object.keys(error.validationErrors).length > 0);
+}
+function mapApiErrorToUiError(error) {
+  const supportTraceId = error.traceId ?? error.correlationId;
+  if (error.isAuthError) {
+    return {
+      i18nKey: "errors.auth.required",
+      params: {},
+      supportTraceId,
+      severity: "warning"
+    };
+  }
+  if (error.isTimeoutError) {
+    return {
+      i18nKey: "errors.network.timeout",
+      params: {},
+      supportTraceId,
+      severity: "error"
+    };
+  }
+  if (error.isNetworkError) {
+    return {
+      i18nKey: "errors.network.unreachable",
+      params: {},
+      supportTraceId,
+      severity: "error"
+    };
+  }
+  if (isValidationError(error)) {
+    return {
+      i18nKey: "errors.validation.generic",
+      params: { status: error.status ?? 400 },
+      supportTraceId,
+      severity: "warning"
+    };
+  }
+  return {
+    i18nKey: "errors.request.failed",
+    params: { status: error.status ?? 500 },
+    supportTraceId,
+    severity: "error"
+  };
+}
+
+// src/services/msalUser.ts
+function toClaims(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
+function pickRoles(claims) {
+  if (!claims) {
+    return void 0;
+  }
+  const roles = claims.roles;
+  if (!Array.isArray(roles)) {
+    return void 0;
+  }
+  return roles.filter((role) => typeof role === "string");
+}
+function pickFirstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function defaultMapUser(account) {
+  const claims = toClaims(account.idTokenClaims);
+  const email = pickFirstString(claims?.preferred_username, claims?.email, claims?.upn);
+  return {
+    id: account.homeAccountId || account.localAccountId,
+    name: pickFirstString(account.name, claims?.name, account.username) || account.username,
+    username: account.username,
+    email: email || account.username,
+    tenantId: account.tenantId,
+    roles: pickRoles(claims),
+    claims
+  };
+}
+function isMsalAccountInfoLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.homeAccountId === "string" && typeof candidate.localAccountId === "string" && typeof candidate.username === "string";
+}
+function dedupeScopes(scopes) {
+  return [...new Set(scopes.filter((scope) => scope.length > 0))];
+}
+function resolveScopes(input, defaults) {
+  if (input && input.length > 0) {
+    return dedupeScopes(input);
+  }
+  return dedupeScopes(defaults);
+}
+function toUserAccessToken(response, fallbackScopes) {
+  return {
+    token: response.accessToken,
+    tokenType: response.tokenType,
+    scopes: response.scopes && response.scopes.length > 0 ? response.scopes : fallbackScopes,
+    expiresAt: response.expiresOn ? response.expiresOn.getTime() : void 0
+  };
+}
+function createMsalUserService(options) {
+  const {
+    msal,
+    defaultScopes = [],
+    loginMode = "popup",
+    logoutMode = "popup",
+    mapUser = defaultMapUser,
+    resolveAccount = (accounts) => accounts[0] ?? null
+  } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  let callbackId = null;
+  let cachedIdToken;
+  let cachedIdTokenClaims;
+  function emitChanged() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function normalizeActiveAccount() {
+    const active = msal.getActiveAccount();
+    if (active) {
+      return active;
+    }
+    const fallback = resolveAccount(msal.getAllAccounts());
+    if (fallback && msal.setActiveAccount) {
+      msal.setActiveAccount(fallback);
+    }
+    return fallback ?? null;
+  }
+  function updateSessionFromResponse(response) {
+    const account = response?.account;
+    if (account && msal.setActiveAccount) {
+      msal.setActiveAccount(account);
+    }
+    if (response?.idToken) {
+      cachedIdToken = response.idToken;
+    }
+    const claims = toClaims(response?.idTokenClaims);
+    if (claims) {
+      cachedIdTokenClaims = claims;
+    }
+  }
+  function resolveAccountById(accountId) {
+    for (const account of msal.getAllAccounts()) {
+      if (account.homeAccountId === accountId || account.localAccountId === accountId) {
+        return account;
+      }
+    }
+    return null;
+  }
+  function attachMsalCallback() {
+    if (callbackId || !msal.addEventCallback) {
+      return;
+    }
+    callbackId = msal.addEventCallback((message) => {
+      const payload = message.payload;
+      if (payload && typeof payload === "object") {
+        const account = payload.account;
+        if (isMsalAccountInfoLike(account) && msal.setActiveAccount) {
+          msal.setActiveAccount(account);
+        }
+      }
+      emitChanged();
+    });
+  }
+  function detachMsalCallback() {
+    if (!callbackId || !msal.removeEventCallback) {
+      callbackId = null;
+      return;
+    }
+    msal.removeEventCallback(callbackId);
+    callbackId = null;
+  }
+  async function acquireAccessToken(request) {
+    const scopes = resolveScopes(request.scopes, defaultScopes);
+    if (scopes.length === 0) {
+      throw new Error("acquireAccessToken requires at least one scope.");
+    }
+    const account = normalizeActiveAccount();
+    if (!account) {
+      return null;
+    }
+    try {
+      const silentResponse = await msal.acquireTokenSilent({
+        scopes,
+        account,
+        forceRefresh: request.forceRefresh,
+        claims: request.claims
+      });
+      updateSessionFromResponse(silentResponse);
+      emitChanged();
+      return toUserAccessToken(silentResponse, scopes);
+    } catch (error) {
+      if (!msal.acquireTokenPopup) {
+        throw error;
+      }
+      const popupResponse = await msal.acquireTokenPopup({
+        scopes,
+        claims: request.claims,
+        account,
+        loginHint: account.username
+      });
+      updateSessionFromResponse(popupResponse);
+      emitChanged();
+      return toUserAccessToken(popupResponse, scopes);
+    }
+  }
+  return {
+    getSnapshot: () => {
+      const account = normalizeActiveAccount();
+      return account ? mapUser(account) : null;
+    },
+    getSession: () => {
+      const account = normalizeActiveAccount();
+      return {
+        state: account ? "authenticated" : "unauthenticated",
+        provider: "msal",
+        account: account ?? void 0,
+        idToken: cachedIdToken,
+        idTokenClaims: cachedIdTokenClaims ?? toClaims(account?.idTokenClaims)
+      };
+    },
+    acquireAccessToken,
+    login: async (loginOptions) => {
+      const scopes = resolveScopes(loginOptions?.scopes, defaultScopes);
+      const request = {
+        scopes: scopes.length > 0 ? scopes : void 0,
+        loginHint: loginOptions?.loginHint,
+        prompt: loginOptions?.prompt
+      };
+      if (loginMode === "redirect") {
+        if (!msal.loginRedirect) {
+          throw new Error("MSAL loginRedirect is not available.");
+        }
+        await msal.loginRedirect(request);
+        return;
+      }
+      if (!msal.loginPopup) {
+        throw new Error("MSAL loginPopup is not available.");
+      }
+      const loginResponse = await msal.loginPopup(request);
+      updateSessionFromResponse(loginResponse);
+      emitChanged();
+    },
+    logout: async (logoutOptions) => {
+      const account = logoutOptions?.accountId ? resolveAccountById(logoutOptions.accountId) : normalizeActiveAccount();
+      const request = {
+        account: account ?? void 0,
+        postLogoutRedirectUri: logoutOptions?.postLogoutRedirectUri
+      };
+      if (logoutMode === "redirect") {
+        if (!msal.logoutRedirect) {
+          throw new Error("MSAL logoutRedirect is not available.");
+        }
+        await msal.logoutRedirect(request);
+        return;
+      }
+      if (!msal.logoutPopup) {
+        throw new Error("MSAL logoutPopup is not available.");
+      }
+      await msal.logoutPopup(request);
+      if (msal.setActiveAccount) {
+        msal.setActiveAccount(null);
+      }
+      cachedIdToken = void 0;
+      cachedIdTokenClaims = void 0;
+      emitChanged();
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      if (listeners.size === 1) {
+        attachMsalCallback();
+      }
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          detachMsalCallback();
+        }
+      };
+    }
+  };
+}
+
+// src/services/reactRouterNavigationAdapter.ts
+function createReactRouterNavigationAdapter(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let navigateFn;
+  let createHrefFn;
+  let currentIndex = resolveWindowHistoryIndex() ?? 0;
+  let maxIndex = currentIndex;
+  const initialLocation = normalizeLocation(options.initialLocation ?? { pathname: "/" });
+  let snapshot = {
+    action: options.initialAction ?? "POP",
+    location: initialLocation,
+    canGoBack: currentIndex > 0,
+    canGoForward: false
+  };
+  function emitChange() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function setSnapshot(nextSnapshot) {
+    if (!hasSnapshotChanged(snapshot, nextSnapshot)) {
+      return;
+    }
+    snapshot = nextSnapshot;
+    emitChange();
+  }
+  function createFallbackHref(to) {
+    return resolveToHref(to, snapshot.location);
+  }
+  const service = {
+    getSnapshot: () => ({
+      action: snapshot.action,
+      location: { ...snapshot.location },
+      canGoBack: snapshot.canGoBack,
+      canGoForward: snapshot.canGoForward
+    }),
+    getPath: () => snapshot.location.pathname,
+    createHref: (to) => {
+      if (createHrefFn) {
+        try {
+          return createHrefFn(to);
+        } catch {
+          return createFallbackHref(to);
+        }
+      }
+      return createFallbackHref(to);
+    },
+    navigate: (to, optionsArg) => {
+      if (!navigateFn) {
+        return;
+      }
+      if (typeof to === "number") {
+        navigateFn(to);
+        return;
+      }
+      const { source: _source, ...routerOptions } = optionsArg ?? {};
+      navigateFn(to, routerOptions);
+    },
+    back: () => {
+      service.navigate(-1);
+    },
+    forward: () => {
+      service.navigate(1);
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  return {
+    service,
+    bindNavigator: (navigate, createHref) => {
+      navigateFn = navigate;
+      createHrefFn = createHref;
+    },
+    clearNavigator: () => {
+      navigateFn = void 0;
+      createHrefFn = void 0;
+    },
+    syncFromRouter: (location, action, capabilities) => {
+      const normalizedLocation = normalizeLocation(location);
+      const runtimeIndex = capabilities?.historyIndex ?? resolveWindowHistoryIndex();
+      if (typeof runtimeIndex === "number" && Number.isInteger(runtimeIndex)) {
+        currentIndex = runtimeIndex;
+        if (runtimeIndex > maxIndex) {
+          maxIndex = runtimeIndex;
+        }
+      } else if (action === "PUSH") {
+        currentIndex += 1;
+        maxIndex = currentIndex;
+      } else if (action === "POP" && currentIndex > 0) {
+        currentIndex -= 1;
+      }
+      const canGoBack = capabilities?.canGoBack ?? currentIndex > 0;
+      const canGoForward = capabilities?.canGoForward ?? currentIndex < maxIndex;
+      setSnapshot({
+        action,
+        location: normalizedLocation,
+        canGoBack,
+        canGoForward
+      });
+    }
+  };
+}
+function resolveWindowHistoryIndex() {
+  if (typeof window === "undefined" || typeof window.history === "undefined") {
+    return void 0;
+  }
+  const historyState = window.history.state;
+  if (!historyState || typeof historyState.idx !== "number") {
+    return void 0;
+  }
+  const idx = historyState.idx;
+  if (!Number.isInteger(idx) || idx < 0) {
+    return void 0;
+  }
+  return idx;
+}
+function normalizeLocation(input) {
+  return {
+    pathname: input.pathname || "/",
+    search: normalizeSearch2(input.search ?? ""),
+    hash: normalizeHash2(input.hash ?? ""),
+    state: input.state,
+    key: input.key || createLocationKey2()
+  };
+}
+function createLocationKey2() {
+  return Math.random().toString(36).slice(2, 10);
+}
+function normalizeSearch2(search) {
+  if (!search) {
+    return "";
+  }
+  return search.startsWith("?") ? search : `?${search}`;
+}
+function normalizeHash2(hash) {
+  if (!hash) {
+    return "";
+  }
+  return hash.startsWith("#") ? hash : `#${hash}`;
+}
+function resolveToHref(to, current) {
+  if (typeof to === "string") {
+    return to;
+  }
+  const pathname = to.pathname ?? current.pathname;
+  const search = to.search !== void 0 ? normalizeSearch2(to.search) : current.search;
+  const hash = to.hash !== void 0 ? normalizeHash2(to.hash) : current.hash;
+  return `${pathname || "/"}${search}${hash}`;
+}
+function hasSnapshotChanged(previous, nextValue) {
+  const prevLocation = previous.location;
+  const nextLocation = nextValue.location;
+  return previous.action !== nextValue.action || previous.canGoBack !== nextValue.canGoBack || previous.canGoForward !== nextValue.canGoForward || prevLocation.pathname !== nextLocation.pathname || prevLocation.search !== nextLocation.search || prevLocation.hash !== nextLocation.hash || prevLocation.key !== nextLocation.key || !Object.is(prevLocation.state, nextLocation.state);
+}
 export {
+  ApiError,
+  createMsalUserService,
+  createReactRouterNavigationAdapter,
+  createRequestContextService,
   createStandaloneApiClient,
   createStandaloneI18nService,
+  createStandaloneRealtimeService,
   createStandaloneUserService,
-  initStandaloneServices
+  initStandaloneServices,
+  isApiError,
+  mapApiErrorToUiError
 };