@powerportalspro/react 5.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,2333 @@
+'use strict';
+
+var react = require('react');
+var core = require('@powerportalspro/core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/context.ts
+var AuthStatus = {
+  Loading: "loading",
+  Anonymous: "anonymous",
+  Authenticated: "authenticated"
+};
+var PowerPortalsProContext = react.createContext(null);
+
+// src/caches/in-memory-cache.ts
+var InMemoryCache = class {
+  constructor(fetcher) {
+    this.fetcher = fetcher;
+  }
+  fetcher;
+  resolved = /* @__PURE__ */ new Map();
+  inFlight = /* @__PURE__ */ new Map();
+  async getAsync(key) {
+    const cached = this.resolved.get(key);
+    if (cached !== void 0) return cached;
+    const pending = this.inFlight.get(key);
+    if (pending) return pending;
+    const promise = (async () => {
+      try {
+        const result = await this.fetcher(key);
+        if (result !== null) this.resolved.set(key, result);
+        return result;
+      } finally {
+        this.inFlight.delete(key);
+      }
+    })();
+    this.inFlight.set(key, promise);
+    return promise;
+  }
+  invalidate(key) {
+    this.resolved.delete(key);
+  }
+  clear() {
+    this.resolved.clear();
+  }
+};
+var InMemoryTableMetadataCache = class {
+  cache;
+  constructor(ppp) {
+    this.cache = new InMemoryCache(
+      (tableLogicalName) => ppp.retrieveTableMetadataAsync(tableLogicalName)
+    );
+  }
+  getAsync(tableLogicalName) {
+    return this.cache.getAsync(tableLogicalName);
+  }
+  invalidate(tableLogicalName) {
+    this.cache.invalidate(tableLogicalName);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var InMemoryViewMetadataCache = class {
+  cache;
+  constructor(ppp) {
+    this.cache = new InMemoryCache(
+      (viewId) => ppp.retrieveViewMetadataAsync(viewId)
+    );
+  }
+  getAsync(viewId) {
+    return this.cache.getAsync(viewId);
+  }
+  invalidate(viewId) {
+    this.cache.invalidate(viewId);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var InMemoryEnvironmentFileSettingsCache = class _InMemoryEnvironmentFileSettingsCache {
+  static KEY = "environment-file-settings";
+  cache;
+  constructor(ppp) {
+    this.cache = new InMemoryCache(
+      () => ppp.getEnvironmentFileSettingsAsync()
+    );
+  }
+  getAsync() {
+    return this.cache.getAsync(_InMemoryEnvironmentFileSettingsCache.KEY);
+  }
+  invalidate() {
+    this.cache.invalidate(_InMemoryEnvironmentFileSettingsCache.KEY);
+  }
+};
+var InMemoryViewsForTableCache = class {
+  cache;
+  constructor(ppp) {
+    this.cache = new InMemoryCache(async (tableLogicalName) => {
+      const result = await ppp.retrieveViewsForTableAsync(tableLogicalName);
+      return result ?? [];
+    });
+  }
+  async getAsync(tableLogicalName) {
+    const result = await this.cache.getAsync(tableLogicalName);
+    return result ?? [];
+  }
+  invalidate(tableLogicalName) {
+    this.cache.invalidate(tableLogicalName);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+function usePowerPortalsPro() {
+  const ctx = react.useContext(PowerPortalsProContext);
+  if (!ctx) {
+    throw new Error(
+      "usePowerPortalsPro must be used inside <PowerPortalsProProvider>. Wrap your app at or near the root."
+    );
+  }
+  return ctx;
+}
+var LocalizerContext = react.createContext(null);
+LocalizerContext.displayName = "Localizer";
+function useLocalizer() {
+  const ctx = react.useContext(LocalizerContext);
+  if (!ctx) {
+    throw new Error(
+      "useLocalizer must be used inside a <LocalizerProvider>. PowerPortalsProProvider auto-mounts a default localizer; ensure your tree is wrapped."
+    );
+  }
+  return ctx;
+}
+function useT() {
+  return useLocalizer().t;
+}
+function usePrefixedT(prefix) {
+  const t = useT();
+  return react.useCallback(
+    (key, args) => t(`${prefix}.${key}`, args),
+    [t, prefix]
+  );
+}
+var LocalizationPrefetcherContext = react.createContext(null);
+LocalizationPrefetcherContext.displayName = "LocalizationPrefetcher";
+function useLocalizationPrefetcher() {
+  return react.useContext(LocalizationPrefetcherContext);
+}
+var NOOP_UNSUBSCRIBE = () => void 0;
+function useLocalization(prefixes) {
+  const prefetcher = useLocalizationPrefetcher();
+  const prefixesKey = react.useMemo(() => {
+    if (prefixes.length === 0) return "";
+    const unique = Array.from(new Set(prefixes));
+    unique.sort();
+    return unique.join("\n");
+  }, [prefixes]);
+  react.useEffect(() => {
+    if (!prefetcher) return;
+    if (prefixesKey === "") return;
+    const tokens = prefixesKey.split("\n");
+    prefetcher.prefetch(tokens);
+    return prefetcher.subscribe(() => {
+      prefetcher.prefetch(tokens);
+    });
+  }, [prefetcher, prefixesKey]);
+}
+function useLocalizationLoaded(prefixes) {
+  const prefetcher = useLocalizationPrefetcher();
+  const subscribe = react.useCallback(
+    (listener) => prefetcher?.subscribe(listener) ?? NOOP_UNSUBSCRIBE,
+    [prefetcher]
+  );
+  const getSnapshot = react.useCallback(
+    () => prefetcher ? prefetcher.isLoaded(prefixes) : true,
+    [prefetcher, prefixes]
+  );
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshotAlwaysLoaded);
+}
+var getServerSnapshotAlwaysLoaded = () => true;
+function LocalizerProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(LocalizerContext.Provider, { value, children });
+}
+function flattenStrings(obj, prefix = "") {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const key = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === "string") {
+      out[key] = v;
+    } else if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      Object.assign(out, flattenStrings(v, key));
+    }
+  }
+  return out;
+}
+function interpolate(template, args) {
+  if (!args || args.length === 0) return template;
+  return template.replace(/\{(\d+)(?::[^}]*)?\}/g, (match, indexStr) => {
+    const idx = Number(indexStr);
+    if (idx < 0 || idx >= args.length) return match;
+    return String(args[idx]);
+  });
+}
+function createLocalizer(strings, options) {
+  const warnedKeys = /* @__PURE__ */ new Set();
+  return {
+    t(key, args) {
+      const template = strings[key];
+      if (template === void 0) {
+        if (options?.onMissingKey && !warnedKeys.has(key)) {
+          warnedKeys.add(key);
+          options.onMissingKey(key);
+        }
+        return key;
+      }
+      return interpolate(template, args);
+    }
+  };
+}
+async function fetchLocalizationJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status} fetching ${url}`);
+  return await response.json();
+}
+function resolveLocalizationUrl(template, locale) {
+  return template.replace(/\{locale\}/g, locale);
+}
+var ASP_NET_CULTURE_COOKIE = ".AspNetCore.Culture";
+function getAspNetCultureCookie() {
+  if (typeof document === "undefined" || !document.cookie) return null;
+  for (const part of document.cookie.split("; ")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = part.substring(0, eq);
+    if (name !== ASP_NET_CULTURE_COOKIE) continue;
+    const value = decodeURIComponent(part.substring(eq + 1));
+    const cMatch = value.match(/c=([^|]+)/);
+    if (cMatch?.[1]) return cMatch[1];
+    return value || null;
+  }
+  return null;
+}
+function setAspNetCultureCookie(culture, options) {
+  if (typeof document === "undefined") return;
+  const path = options?.path ?? "/";
+  const maxAge = options?.maxAgeSeconds ?? 31536e3;
+  const value = encodeURIComponent(`c=${culture}|uic=${culture}`);
+  document.cookie = `${ASP_NET_CULTURE_COOKIE}=${value}; path=${path}; max-age=${maxAge}; samesite=lax`;
+}
+var DEFAULT_URL_LOCALE_PATTERN = /^\/([a-z]{2}(?:-[a-zA-Z]{2,4})?)(?:\/|$)/;
+function getLocaleFromUrlPath(pattern = DEFAULT_URL_LOCALE_PATTERN) {
+  if (typeof window === "undefined") return null;
+  const match = window.location.pathname.match(pattern);
+  return match?.[1] ?? null;
+}
+function detectLocale(options) {
+  const {
+    matchUrl = true,
+    urlPattern = DEFAULT_URL_LOCALE_PATTERN,
+    matchBrowser = true,
+    fallback = "en"
+  } = options ?? {};
+  if (matchUrl) {
+    const fromUrl = getLocaleFromUrlPath(urlPattern);
+    if (fromUrl) return fromUrl;
+  }
+  const fromCookie = getAspNetCultureCookie();
+  if (fromCookie) return fromCookie;
+  if (matchBrowser && typeof navigator !== "undefined" && navigator.language) {
+    const primary = navigator.language.split("-")[0];
+    if (primary) return primary;
+  }
+  return fallback;
+}
+var MISSING_KEY_FLUSH_DELAY_MS = 75;
+var DEFAULT_BUNDLE_SENTINEL = "defaultBundle";
+function coerceKeyToToken(key) {
+  if (!key) return null;
+  const lower = key.toLowerCase();
+  if (!lower.startsWith("tables.")) return null;
+  const afterTables = lower.substring("tables.".length);
+  const firstDot = afterTables.indexOf(".");
+  if (firstDot < 0) return `tables.${afterTables}`;
+  const tableName = afterTables.substring(0, firstDot);
+  const afterTable = afterTables.substring(firstDot + 1);
+  if (afterTable.startsWith("views.")) {
+    const afterViews = afterTable.substring("views.".length);
+    const nextDot = afterViews.indexOf(".");
+    const viewId = nextDot < 0 ? afterViews : afterViews.substring(0, nextDot);
+    if (!viewId) return null;
+    return `views.${viewId}`;
+  }
+  return `tables.${tableName}`;
+}
+function coercePrefixToToken(prefix) {
+  if (!prefix) return null;
+  const lower = prefix.toLowerCase();
+  if (lower.startsWith("views.")) {
+    const afterViews = lower.substring("views.".length);
+    const nextDot = afterViews.indexOf(".");
+    const viewId = nextDot < 0 ? afterViews : afterViews.substring(0, nextDot);
+    return viewId ? `views.${viewId}` : null;
+  }
+  return coerceKeyToToken(prefix);
+}
+var LocaleContext = react.createContext(null);
+LocaleContext.displayName = "Locale";
+var LocalizationManifestContext = react.createContext(null);
+LocalizationManifestContext.displayName = "LocalizationManifest";
+function useLocale() {
+  const ctx = react.useContext(LocaleContext);
+  return ctx ?? { locale: "en", setLocale: noopSetLocale };
+}
+var noopSetLocale = (_) => void 0;
+function LocaleProvider({
+  initialLocale = "en",
+  autoDetect = true,
+  urlPattern,
+  persistToCookie = true,
+  locale: controlledLocale,
+  onLocaleChange,
+  children
+}) {
+  const [internalLocale, setInternalLocale] = react.useState(() => {
+    if (!autoDetect) return initialLocale;
+    return detectLocale({
+      matchUrl: urlPattern !== null,
+      ...urlPattern instanceof RegExp && { urlPattern },
+      fallback: initialLocale
+    });
+  });
+  const isControlled = controlledLocale !== void 0;
+  const locale = isControlled ? controlledLocale : internalLocale;
+  const setLocale = react.useCallback(
+    (next) => {
+      if (!isControlled) setInternalLocale(next);
+      if (persistToCookie) setAspNetCultureCookie(next);
+      onLocaleChange?.(next);
+    },
+    [isControlled, persistToCookie, onLocaleChange]
+  );
+  const value = react.useMemo(() => ({ locale, setLocale }), [locale, setLocale]);
+  return /* @__PURE__ */ jsxRuntime.jsx(LocaleContext.Provider, { value, children });
+}
+function defaultMissingKeyWarning(key) {
+  console.warn(`PowerPortalsPro: missing localization key "${key}"`);
+}
+function DefaultLocalizerProvider({
+  urls,
+  url,
+  onMissingKey = defaultMissingKeyWarning,
+  prefixes,
+  children
+}) {
+  const [cache, setCache] = react.useState({});
+  const [supportedLocales, setSupportedLocales] = react.useState(void 0);
+  const { locale } = useLocale();
+  const { ppp } = usePowerPortalsPro();
+  const localeRef = react.useRef(locale);
+  localeRef.current = locale;
+  const pppRef = react.useRef(ppp);
+  pppRef.current = ppp;
+  const resolvedLocaleRef = react.useRef(null);
+  const thumbprintsRef = react.useRef(null);
+  const pendingTokensRef = react.useRef(/* @__PURE__ */ new Set());
+  const triedTokensRef = react.useRef(/* @__PURE__ */ new Set());
+  const pendingTimerRef = react.useRef(null);
+  const settledTokensRef = react.useRef(/* @__PURE__ */ new Set());
+  const listenersRef = react.useRef(/* @__PURE__ */ new Set());
+  const baselinePrefixesRef = react.useRef([]);
+  const baselineTokensRef = react.useRef([]);
+  const baselinePrefixesKey = react.useMemo(() => {
+    const input = prefixes ?? [];
+    if (input.length === 0) {
+      baselinePrefixesRef.current = [];
+      baselineTokensRef.current = [];
+      return "";
+    }
+    const unique = Array.from(new Set(input));
+    unique.sort();
+    baselinePrefixesRef.current = unique;
+    const tokens = [];
+    for (const p of unique) {
+      const t = coercePrefixToToken(p);
+      if (t !== null) tokens.push(t);
+    }
+    baselineTokensRef.current = tokens;
+    return unique.join("\n");
+  }, [prefixes]);
+  const notifyListeners = react.useCallback(() => {
+    const snapshot = Array.from(listenersRef.current);
+    for (const listener of snapshot) listener();
+  }, []);
+  const previousRunRef = react.useRef(null);
+  const flushPendingRef = react.useRef(() => void 0);
+  const overlayTemplates = urls ?? (url !== void 0 ? [url] : []);
+  const resolvedOverlayUrls = overlayTemplates.map((t) => resolveLocalizationUrl(t, locale));
+  const overlayUrlsKey = resolvedOverlayUrls.join("\n");
+  react.useEffect(() => {
+    let cancelled = false;
+    const previous = previousRunRef.current;
+    const isLocaleOrUrlChange = previous !== null && (previous.locale !== locale || previous.overlayKey !== overlayUrlsKey);
+    previousRunRef.current = { locale, overlayKey: overlayUrlsKey };
+    if (isLocaleOrUrlChange) {
+      setCache({});
+      setSupportedLocales(void 0);
+      pendingTokensRef.current = /* @__PURE__ */ new Set();
+      triedTokensRef.current = /* @__PURE__ */ new Set();
+      if (pendingTimerRef.current !== null) {
+        clearTimeout(pendingTimerRef.current);
+        pendingTimerRef.current = null;
+      }
+      if (settledTokensRef.current.size > 0) {
+        settledTokensRef.current = /* @__PURE__ */ new Set();
+        notifyListeners();
+      }
+    }
+    resolvedLocaleRef.current = null;
+    thumbprintsRef.current = null;
+    const overlayList = overlayUrlsKey.split("\n").filter((u) => u.length > 0);
+    (async () => {
+      try {
+        const manifest = await pppRef.current.retrieveLocalizationBundleManifestAsync();
+        if (cancelled) return;
+        setSupportedLocales(manifest.supportedLocales);
+        const resolvedLocale = manifest.supportedLocales.includes(locale) ? locale : manifest.supportedLocales[0] ?? locale;
+        const thumbs = await pppRef.current.retrieveLocalizationThumbprintsAsync(resolvedLocale);
+        if (cancelled) return;
+        resolvedLocaleRef.current = resolvedLocale;
+        thumbprintsRef.current = thumbs;
+        const [bundleData, ...overlayDatas] = await Promise.all([
+          pppRef.current.retrieveLocalizationBundleAsync(resolvedLocale, thumbs.bundle),
+          ...overlayList.map(fetchLocalizationJson)
+        ]);
+        if (cancelled) return;
+        const merged = {};
+        Object.assign(merged, flattenStrings(bundleData));
+        for (const data of overlayDatas) {
+          Object.assign(merged, flattenStrings(data));
+        }
+        setCache(merged);
+      } catch (e) {
+        if (cancelled) return;
+        console.error(
+          "PowerPortalsPro: failed to load localization bundle; staying on key-fallback localizer.",
+          e
+        );
+      }
+      if (cancelled) return;
+      settledTokensRef.current.add(DEFAULT_BUNDLE_SENTINEL);
+      for (const token of baselineTokensRef.current) {
+        if (triedTokensRef.current.has(token)) continue;
+        if (pendingTokensRef.current.has(token)) continue;
+        pendingTokensRef.current.add(token);
+      }
+      if (pendingTokensRef.current.size > 0 && pendingTimerRef.current === null) {
+        pendingTimerRef.current = setTimeout(
+          () => flushPendingRef.current(),
+          MISSING_KEY_FLUSH_DELAY_MS
+        );
+      }
+      notifyListeners();
+    })();
+    return () => {
+      cancelled = true;
+      if (pendingTimerRef.current !== null) {
+        clearTimeout(pendingTimerRef.current);
+        pendingTimerRef.current = null;
+      }
+    };
+  }, [locale, overlayUrlsKey]);
+  const flushPending = react.useCallback(async () => {
+    pendingTimerRef.current = null;
+    const tokensToFetch = Array.from(pendingTokensRef.current);
+    if (tokensToFetch.length === 0) return;
+    pendingTokensRef.current = /* @__PURE__ */ new Set();
+    for (const tok of tokensToFetch) {
+      triedTokensRef.current.add(tok);
+    }
+    const thumbs = thumbprintsRef.current;
+    const requestLocale = resolvedLocaleRef.current;
+    if (!thumbs || !requestLocale) {
+      for (const tok of tokensToFetch) {
+        triedTokensRef.current.delete(tok);
+        pendingTokensRef.current.add(tok);
+      }
+      return;
+    }
+    const fetches = tokensToFetch.map(async (token) => {
+      try {
+        if (token.startsWith("tables.")) {
+          const tableName = token.substring("tables.".length);
+          const thumb = thumbs.tables[tableName];
+          if (!thumb) return null;
+          return await pppRef.current.retrieveLocalizationTableBundleAsync(
+            tableName,
+            requestLocale,
+            thumb
+          );
+        }
+        if (token.startsWith("views.")) {
+          const viewId = token.substring("views.".length);
+          const thumb = thumbs.views[viewId];
+          if (!thumb) return null;
+          return await pppRef.current.retrieveLocalizationViewBundleAsync(
+            viewId,
+            requestLocale,
+            thumb
+          );
+        }
+        return null;
+      } catch (e) {
+        console.warn(`PowerPortalsPro: localization fetch failed for token ${token}`, e);
+        triedTokensRef.current.delete(token);
+        return null;
+      }
+    });
+    const responses = await Promise.all(fetches);
+    if (requestLocale !== resolvedLocaleRef.current) return;
+    let settledChanged = false;
+    for (const tok of tokensToFetch) {
+      if (!settledTokensRef.current.has(tok)) {
+        settledTokensRef.current.add(tok);
+        settledChanged = true;
+      }
+    }
+    const merged = {};
+    for (const data of responses) {
+      if (data === null) continue;
+      Object.assign(merged, flattenStrings(data));
+    }
+    if (Object.keys(merged).length > 0) {
+      setCache((prev) => ({ ...prev, ...merged }));
+    }
+    if (settledChanged) {
+      notifyListeners();
+    }
+  }, [notifyListeners]);
+  flushPendingRef.current = flushPending;
+  react.useEffect(() => {
+    if (!settledTokensRef.current.has(DEFAULT_BUNDLE_SENTINEL)) return;
+    let added = false;
+    for (const token of baselineTokensRef.current) {
+      if (triedTokensRef.current.has(token)) continue;
+      if (pendingTokensRef.current.has(token)) continue;
+      pendingTokensRef.current.add(token);
+      added = true;
+    }
+    if (pendingTokensRef.current.size > 0 && pendingTimerRef.current === null) {
+      pendingTimerRef.current = setTimeout(flushPending, MISSING_KEY_FLUSH_DELAY_MS);
+    }
+    if (added) notifyListeners();
+  }, [baselinePrefixesKey, flushPending, notifyListeners]);
+  const queueMissingKey = react.useCallback(
+    (key) => {
+      const token = coerceKeyToToken(key);
+      if (token === null) return;
+      if (triedTokensRef.current.has(token)) return;
+      if (pendingTokensRef.current.has(token)) return;
+      pendingTokensRef.current.add(token);
+      if (pendingTimerRef.current === null) {
+        pendingTimerRef.current = setTimeout(flushPending, MISSING_KEY_FLUSH_DELAY_MS);
+      }
+    },
+    [flushPending]
+  );
+  const onMissingKeyCombined = react.useCallback(
+    (key) => {
+      onMissingKey(key);
+      queueMissingKey(key);
+    },
+    [onMissingKey, queueMissingKey]
+  );
+  const localizer = react.useMemo(
+    () => createLocalizer(cache, { onMissingKey: onMissingKeyCombined }),
+    [cache, onMissingKeyCombined]
+  );
+  const prefetcher = react.useMemo(
+    () => ({
+      prefetch(prefixes2) {
+        for (const prefix of prefixes2) {
+          const token = coercePrefixToToken(prefix);
+          if (token === null) continue;
+          if (triedTokensRef.current.has(token)) continue;
+          if (pendingTokensRef.current.has(token)) continue;
+          pendingTokensRef.current.add(token);
+        }
+        if (pendingTokensRef.current.size > 0 && pendingTimerRef.current === null) {
+          pendingTimerRef.current = setTimeout(flushPending, MISSING_KEY_FLUSH_DELAY_MS);
+        }
+      },
+      isLoaded(prefixes2) {
+        if (!settledTokensRef.current.has(DEFAULT_BUNDLE_SENTINEL)) return false;
+        for (const token of baselineTokensRef.current) {
+          if (!settledTokensRef.current.has(token)) return false;
+        }
+        for (const prefix of prefixes2) {
+          const token = coercePrefixToToken(prefix);
+          if (token === null) continue;
+          if (!settledTokensRef.current.has(token)) return false;
+        }
+        return true;
+      },
+      subscribe(listener) {
+        listenersRef.current.add(listener);
+        return () => {
+          listenersRef.current.delete(listener);
+        };
+      }
+    }),
+    [flushPending]
+  );
+  const manifestContextValue = react.useMemo(
+    () => ({ supportedLocales }),
+    [supportedLocales]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(LocalizationManifestContext.Provider, { value: manifestContextValue, children: /* @__PURE__ */ jsxRuntime.jsx(LocalizationPrefetcherContext.Provider, { value: prefetcher, children: /* @__PURE__ */ jsxRuntime.jsx(LocalizerProvider, { value: localizer, children }) }) });
+}
+var UnsavedChangesRegistryContext = react.createContext(null);
+UnsavedChangesRegistryContext.displayName = "UnsavedChangesRegistry";
+function UnsavedChangesRegistryProvider({ children }) {
+  const reportersRef = react.useRef(/* @__PURE__ */ new Set());
+  const listenersRef = react.useRef(/* @__PURE__ */ new Set());
+  const notify = react.useCallback(() => {
+    for (const listener of listenersRef.current) listener();
+  }, []);
+  const register = react.useCallback(
+    (reporter) => {
+      reportersRef.current.add(reporter);
+      notify();
+      return () => {
+        reportersRef.current.delete(reporter);
+        notify();
+      };
+    },
+    [notify]
+  );
+  const subscribe = react.useCallback((listener) => {
+    listenersRef.current.add(listener);
+    return () => {
+      listenersRef.current.delete(listener);
+    };
+  }, []);
+  const isAnyDirty = react.useCallback(() => {
+    for (const reporter of reportersRef.current) {
+      if (reporter.isDirty()) return true;
+    }
+    return false;
+  }, []);
+  const registry = react.useMemo(
+    () => ({ register, subscribe, isAnyDirty, notifyDirtyChanged: notify }),
+    [register, subscribe, isAnyDirty, notify]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(UnsavedChangesRegistryContext.Provider, { value: registry, children });
+}
+function useUnsavedChangesRegistry() {
+  return react.useContext(UnsavedChangesRegistryContext);
+}
+function useIsAnyDirty() {
+  const registry = useUnsavedChangesRegistry();
+  const subscribe = react.useCallback(
+    (listener) => {
+      if (!registry) return () => {
+      };
+      return registry.subscribe(listener);
+    },
+    [registry]
+  );
+  const getSnapshot = react.useCallback(() => {
+    if (!registry) return false;
+    return registry.isAnyDirty();
+  }, [registry]);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function PowerPortalsProProvider({
+  children,
+  transport,
+  localizationUrl,
+  localizationUrls,
+  localizationPrefixes,
+  tableMetadataCache,
+  viewMetadataCache,
+  viewsForTableCache,
+  environmentFileSettingsCache
+}) {
+  const transportRef = react.useRef(null);
+  if (transportRef.current === null) {
+    transportRef.current = transport ?? new core.Transport();
+  }
+  const transportInstance = transportRef.current;
+  const auth = react.useMemo(() => new core.AuthClient(transportInstance), [transportInstance]);
+  const ppp = react.useMemo(() => new core.PowerPortalsProClient(transportInstance), [transportInstance]);
+  const resolvedTableMetadataCache = react.useMemo(
+    () => tableMetadataCache ?? new InMemoryTableMetadataCache(ppp),
+    [ppp, tableMetadataCache]
+  );
+  const resolvedViewMetadataCache = react.useMemo(
+    () => viewMetadataCache ?? new InMemoryViewMetadataCache(ppp),
+    [ppp, viewMetadataCache]
+  );
+  const resolvedViewsForTableCache = react.useMemo(
+    () => viewsForTableCache ?? new InMemoryViewsForTableCache(ppp),
+    [ppp, viewsForTableCache]
+  );
+  const resolvedEnvironmentFileSettingsCache = react.useMemo(
+    () => environmentFileSettingsCache ?? new InMemoryEnvironmentFileSettingsCache(ppp),
+    [ppp, environmentFileSettingsCache]
+  );
+  const [authState, setAuthState] = react.useState({ status: AuthStatus.Loading });
+  const refreshAuth = react.useCallback(async () => {
+    try {
+      const me = await auth.getCurrentUserAsync();
+      if (me.isAuthenticated) {
+        setAuthState({ status: AuthStatus.Authenticated, user: me });
+      } else {
+        setAuthState({ status: AuthStatus.Anonymous });
+      }
+    } catch {
+      setAuthState({ status: AuthStatus.Anonymous });
+    }
+  }, [auth]);
+  const login = react.useCallback(
+    async (request) => {
+      const response = await auth.loginAsync(request);
+      if (response.result === core.LoginResult.Success) {
+        await refreshAuth();
+      }
+      return response;
+    },
+    [auth, refreshAuth]
+  );
+  const logout = react.useCallback(async () => {
+    await auth.logoutAsync();
+    setAuthState({ status: AuthStatus.Anonymous });
+  }, [auth]);
+  const switchIdentity = react.useCallback(async () => {
+    const response = await auth.switchIdentityAsync();
+    if (response.result === core.SwitchIdentityResult.Switched) {
+      await refreshAuth();
+    }
+    return response;
+  }, [auth, refreshAuth]);
+  react.useEffect(() => {
+    refreshAuth();
+  }, [refreshAuth]);
+  const value = react.useMemo(
+    () => ({
+      transport: transportInstance,
+      auth,
+      ppp,
+      tableMetadataCache: resolvedTableMetadataCache,
+      viewMetadataCache: resolvedViewMetadataCache,
+      viewsForTableCache: resolvedViewsForTableCache,
+      environmentFileSettingsCache: resolvedEnvironmentFileSettingsCache,
+      authState,
+      refreshAuth,
+      login,
+      logout,
+      switchIdentity
+    }),
+    [
+      transportInstance,
+      auth,
+      ppp,
+      resolvedTableMetadataCache,
+      resolvedViewMetadataCache,
+      resolvedViewsForTableCache,
+      resolvedEnvironmentFileSettingsCache,
+      authState,
+      refreshAuth,
+      login,
+      logout,
+      switchIdentity
+    ]
+  );
+  let localizationContent;
+  if (localizationUrl === false) {
+    localizationContent = children;
+  } else {
+    const overlayUrls = [];
+    if (typeof localizationUrl === "string") overlayUrls.push(localizationUrl);
+    if (localizationUrls) overlayUrls.push(...localizationUrls);
+    localizationContent = /* @__PURE__ */ jsxRuntime.jsxs(LocaleProvider, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(CacheLocaleSync, {}),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        DefaultLocalizerProvider,
+        {
+          ...overlayUrls.length > 0 && { urls: overlayUrls },
+          ...localizationPrefixes !== void 0 && { prefixes: localizationPrefixes },
+          children
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(PowerPortalsProContext.Provider, { value, children: /* @__PURE__ */ jsxRuntime.jsx(UnsavedChangesRegistryProvider, { children: localizationContent }) });
+}
+function CacheLocaleSync() {
+  const { locale } = useLocale();
+  const {
+    tableMetadataCache,
+    viewMetadataCache,
+    viewsForTableCache,
+    environmentFileSettingsCache
+  } = usePowerPortalsPro();
+  const isFirstRun = react.useRef(true);
+  react.useEffect(() => {
+    if (isFirstRun.current) {
+      isFirstRun.current = false;
+      return;
+    }
+    tableMetadataCache.clear();
+    viewMetadataCache.clear();
+    viewsForTableCache.clear();
+    environmentFileSettingsCache.invalidate();
+  }, [
+    locale,
+    tableMetadataCache,
+    viewMetadataCache,
+    viewsForTableCache,
+    environmentFileSettingsCache
+  ]);
+  return null;
+}
+
+// src/use-auth.ts
+function useAuth() {
+  const { authState, refreshAuth, login, logout, switchIdentity } = usePowerPortalsPro();
+  return {
+    ...authState,
+    refresh: refreshAuth,
+    login,
+    logout,
+    switchIdentity
+  };
+}
+function AuthorizedView({ children, roles, fallback = null }) {
+  const auth = useAuth();
+  if (auth.status !== AuthStatus.Authenticated) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+  if (roles !== void 0) {
+    const required = typeof roles === "string" ? [roles] : roles;
+    if (required.length > 0) {
+      const userRoles = auth.user.roles ?? [];
+      const hasAny = required.some((r) => userRoles.includes(r));
+      if (!hasAny) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+    }
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+}
+var QueryStatus = {
+  Loading: "loading",
+  Success: "success",
+  Error: "error"
+};
+function useAsyncResource(fetcher, deps, enabled = true, keepPreviousData = false) {
+  const [state, setState] = react.useState({
+    status: enabled ? QueryStatus.Loading : QueryStatus.Success,
+    data: void 0,
+    error: void 0,
+    isFetching: enabled
+  });
+  const [refetchTick, setRefetchTick] = react.useState(0);
+  const pendingResolversRef = react.useRef([]);
+  react.useEffect(() => {
+    if (!enabled) {
+      setState({
+        status: QueryStatus.Success,
+        data: void 0,
+        error: void 0,
+        isFetching: false
+      });
+      const resolvers = pendingResolversRef.current;
+      pendingResolversRef.current = [];
+      for (const r of resolvers) r.resolve();
+      return;
+    }
+    const controller = new AbortController();
+    setState((prev) => {
+      if (keepPreviousData && prev.status === QueryStatus.Success && prev.data !== void 0) {
+        if (prev.isFetching && prev.error === void 0) return prev;
+        return { ...prev, error: void 0, isFetching: true };
+      }
+      if (prev.status === QueryStatus.Loading && prev.data === void 0 && prev.error === void 0 && prev.isFetching) {
+        return prev;
+      }
+      return {
+        status: QueryStatus.Loading,
+        data: void 0,
+        error: void 0,
+        isFetching: true
+      };
+    });
+    fetcher(controller.signal).then(
+      (data) => {
+        if (!controller.signal.aborted) {
+          setState({
+            status: QueryStatus.Success,
+            data,
+            error: void 0,
+            isFetching: false
+          });
+        }
+        const resolvers = pendingResolversRef.current;
+        pendingResolversRef.current = [];
+        for (const r of resolvers) r.resolve();
+      },
+      (err) => {
+        if (controller.signal.aborted || err instanceof Error && err.name === "AbortError") {
+          const resolvers2 = pendingResolversRef.current;
+          pendingResolversRef.current = [];
+          for (const r of resolvers2) r.resolve();
+          return;
+        }
+        setState({
+          status: QueryStatus.Error,
+          data: void 0,
+          error: err,
+          isFetching: false
+        });
+        const resolvers = pendingResolversRef.current;
+        pendingResolversRef.current = [];
+        for (const r of resolvers) r.reject(err);
+      }
+    );
+    return () => {
+      controller.abort();
+      const resolvers = pendingResolversRef.current;
+      pendingResolversRef.current = [];
+      for (const r of resolvers) r.resolve();
+    };
+  }, [...deps, enabled, refetchTick]);
+  const refetch = react.useCallback(() => {
+    return new Promise((resolve, reject) => {
+      pendingResolversRef.current.push({ resolve, reject });
+      setRefetchTick((n) => n + 1);
+    });
+  }, []);
+  return { ...state, refetch };
+}
+
+// src/use-record.ts
+function useRecord(tableLogicalName, recordId, options) {
+  const { ppp } = usePowerPortalsPro();
+  const columns = options?.columns;
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    (signal) => ppp.retrieveRecordAsync(tableLogicalName, recordId, columns, signal),
+    // Joining the columns array is the cheapest way to get a stable dep without
+    // forcing the consumer to memoize. Column lists are short (typically <20).
+    [ppp, tableLogicalName, recordId, columns?.join(",") ?? ""],
+    enabled
+  );
+}
+
+// src/use-fetch-records.ts
+function useFetchRecords(fetchXml, options) {
+  const { ppp } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    (signal) => ppp.retrieveRecordsAsync(fetchXml, signal),
+    [ppp, fetchXml],
+    enabled
+  );
+}
+
+// src/use-grid-data.ts
+function useGridData(request, options) {
+  const { ppp } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  const keepPreviousData = options?.keepPreviousData ?? false;
+  const requestKey = JSON.stringify(request);
+  return useAsyncResource(
+    (signal) => ppp.loadGridAsync(request, signal),
+    [ppp, requestKey],
+    enabled,
+    keepPreviousData
+  );
+}
+function reduce(state, action) {
+  switch (action.type) {
+    // Filter / sort / search / pageSize changes invalidate the current
+    // page — the new result set has different rows, the user expects to
+    // land on page 1. Mirrors what `<MainGrid>` does for standalone
+    // mode. Highlight changes DON'T reset the page (purely client-side).
+    case "setFilter":
+      return { ...state, filter: action.filter, page: 1 };
+    case "setSort":
+      return { ...state, sort: action.sort, page: 1 };
+    case "setSearch":
+      return { ...state, search: action.search, page: 1 };
+    case "setPage":
+      return { ...state, page: action.page };
+    case "setPageSize":
+      return { ...state, pageSize: action.pageSize, page: 1 };
+    case "setHighlight":
+      return { ...state, highlight: action.highlight };
+  }
+}
+function useViewDataSource(options) {
+  const debounceMs = options.debounceMs ?? 300;
+  const enabled = options.enabled ?? true;
+  const keepPreviousData = options.keepPreviousData ?? true;
+  const [state, dispatch] = react.useReducer(reduce, void 0, () => ({
+    filter: options.initialFilter ?? EMPTY_FILTERS,
+    sort: options.initialSort ?? EMPTY_SORTS,
+    search: options.initialSearch ?? "",
+    page: options.initialPage ?? 1,
+    pageSize: options.initialPageSize ?? 50,
+    highlight: options.initialHighlight
+  }));
+  const aggregationFingerprint = react.useMemo(() => {
+    if (!options.aggregations || options.aggregations.length === 0) return null;
+    return JSON.stringify({
+      viewId: options.viewId,
+      fetchXml: options.fetchXml,
+      staticFilters: options.staticFilters,
+      filter: state.filter,
+      search: state.search,
+      aggregations: options.aggregations
+    });
+  }, [
+    options.viewId,
+    options.fetchXml,
+    options.staticFilters,
+    options.aggregations,
+    state.filter,
+    state.search
+  ]);
+  const lastFetchedAggregationFingerprintRef = react.useRef(null);
+  const cachedAggregationResultsRef = react.useRef(EMPTY_AGGREGATIONS);
+  const request = react.useMemo(() => {
+    const filters = [
+      ...options.staticFilters ?? [],
+      ...state.filter
+    ];
+    const includeAggregations = aggregationFingerprint !== null && aggregationFingerprint !== lastFetchedAggregationFingerprintRef.current;
+    return {
+      ...options.viewId !== void 0 && { viewId: options.viewId },
+      ...options.fetchXml !== void 0 && { fetchXml: options.fetchXml },
+      sorts: state.sort,
+      pageNumber: state.page,
+      pageSize: state.pageSize,
+      ...state.search !== "" && { searchText: state.search },
+      ...filters.length > 0 && { filters },
+      ...includeAggregations && options.aggregations && {
+        aggregations: options.aggregations
+      }
+    };
+  }, [
+    options.viewId,
+    options.fetchXml,
+    options.staticFilters,
+    options.aggregations,
+    state.filter,
+    state.sort,
+    state.search,
+    state.page,
+    state.pageSize,
+    aggregationFingerprint
+  ]);
+  const debouncedRequest = useDebouncedValue(request, debounceMs);
+  const query = useGridData(debouncedRequest, { enabled, keepPreviousData });
+  const setFilter = react.useCallback((filter) => {
+    dispatch({ type: "setFilter", filter });
+  }, []);
+  const setSort = react.useCallback((sort) => {
+    dispatch({ type: "setSort", sort });
+  }, []);
+  const setSearch = react.useCallback((search) => {
+    dispatch({ type: "setSearch", search });
+  }, []);
+  const setPage = react.useCallback((page) => {
+    dispatch({ type: "setPage", page });
+  }, []);
+  const setPageSize = react.useCallback((pageSize) => {
+    dispatch({ type: "setPageSize", pageSize });
+  }, []);
+  const setHighlight = react.useCallback((highlight) => {
+    dispatch({ type: "setHighlight", highlight });
+  }, []);
+  const refresh = react.useCallback(async () => {
+    await query.refetch();
+  }, [query.refetch]);
+  const data = query.data;
+  const rows = data?.tableRecords ?? EMPTY_RECORDS;
+  const columns = data?.columns ?? EMPTY_COLUMNS;
+  const totalCount = data?.pagingInfo?.totalRecordCount;
+  const tablePermissions = data?.tablePermissions;
+  const aggregations = options.aggregations ?? EMPTY_AGGREGATION_SPEC;
+  const isFetchingAggregations = query.isFetching && debouncedRequest.aggregations !== void 0 && debouncedRequest.aggregations !== null && debouncedRequest.aggregations.length > 0;
+  const lastSeenDataRef = react.useRef(void 0);
+  react.useEffect(() => {
+    if (data === lastSeenDataRef.current) return;
+    lastSeenDataRef.current = data;
+    if (data?.aggregations) {
+      cachedAggregationResultsRef.current = data.aggregations;
+      lastFetchedAggregationFingerprintRef.current = aggregationFingerprint;
+    }
+  }, [data, aggregationFingerprint]);
+  const aggregationResults = (options.aggregations?.length ?? 0) === 0 ? EMPTY_AGGREGATIONS : data?.aggregations ?? cachedAggregationResultsRef.current;
+  return react.useMemo(
+    () => ({
+      filter: state.filter,
+      sort: state.sort,
+      search: state.search,
+      page: state.page,
+      pageSize: state.pageSize,
+      highlight: state.highlight,
+      aggregations,
+      status: query.status,
+      rows,
+      totalCount,
+      columns,
+      tablePermissions,
+      aggregationResults,
+      error: query.error,
+      isFetching: query.isFetching,
+      isFetchingAggregations,
+      setFilter,
+      setSort,
+      setSearch,
+      setPage,
+      setPageSize,
+      setHighlight,
+      refresh
+    }),
+    [
+      state.filter,
+      state.sort,
+      state.search,
+      state.page,
+      state.pageSize,
+      state.highlight,
+      aggregations,
+      query.status,
+      rows,
+      totalCount,
+      columns,
+      tablePermissions,
+      aggregationResults,
+      query.error,
+      query.isFetching,
+      isFetchingAggregations,
+      setFilter,
+      setSort,
+      setSearch,
+      setPage,
+      setPageSize,
+      setHighlight,
+      refresh
+    ]
+  );
+}
+var EMPTY_FILTERS = [];
+var EMPTY_SORTS = [];
+var EMPTY_RECORDS = [];
+var EMPTY_COLUMNS = [];
+var EMPTY_AGGREGATIONS = [];
+var EMPTY_AGGREGATION_SPEC = [];
+function useDebouncedValue(value, delayMs) {
+  const [debounced, setDebounced] = react.useState(value);
+  const valueKey = JSON.stringify(value);
+  const previousKeyRef = react.useRef(valueKey);
+  react.useEffect(() => {
+    if (delayMs === 0) {
+      setDebounced(value);
+      previousKeyRef.current = valueKey;
+      return;
+    }
+    if (previousKeyRef.current === valueKey) return;
+    const timer = setTimeout(() => {
+      setDebounced(value);
+      previousKeyRef.current = valueKey;
+    }, delayMs);
+    return () => clearTimeout(timer);
+  }, [valueKey, delayMs]);
+  return debounced;
+}
+
+// src/use-table-metadata.ts
+function useTableMetadata(tableLogicalName, options) {
+  const { tableMetadataCache } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    async () => {
+      const result = await tableMetadataCache.getAsync(tableLogicalName);
+      return result ?? void 0;
+    },
+    [tableMetadataCache, tableLogicalName],
+    enabled
+  );
+}
+
+// src/use-table-permissions.ts
+function useTablePermissions(tableLogicalName, options) {
+  const { ppp } = usePowerPortalsPro();
+  const enabled = (options?.enabled ?? true) && tableLogicalName.length > 0;
+  return useAsyncResource(
+    async () => ppp.retrieveTablePermissionsAsync(tableLogicalName),
+    [ppp, tableLogicalName],
+    enabled
+  );
+}
+
+// src/use-view-metadata.ts
+function useViewMetadata(viewId, options) {
+  const { viewMetadataCache } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    async () => {
+      const result = await viewMetadataCache.getAsync(viewId);
+      return result ?? void 0;
+    },
+    [viewMetadataCache, viewId],
+    enabled
+  );
+}
+
+// src/use-views-for-table.ts
+function useViewsForTable(tableLogicalName, options) {
+  const { viewsForTableCache } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    () => viewsForTableCache.getAsync(tableLogicalName),
+    [viewsForTableCache, tableLogicalName],
+    enabled
+  );
+}
+
+// src/use-environment-file-settings.ts
+function useEnvironmentFileSettings(options) {
+  const { environmentFileSettingsCache } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  return useAsyncResource(
+    async () => {
+      const result = await environmentFileSettingsCache.getAsync();
+      return result ?? void 0;
+    },
+    [environmentFileSettingsCache],
+    enabled
+  );
+}
+function useSupportedLocales(options) {
+  const { ppp } = usePowerPortalsPro();
+  const enabled = options?.enabled ?? true;
+  const manifestState = react.useContext(LocalizationManifestContext);
+  const providerScoped = manifestState !== null;
+  const fallback = useAsyncResource(
+    async () => {
+      const manifest = await ppp.retrieveLocalizationBundleManifestAsync();
+      return manifest.supportedLocales;
+    },
+    [ppp],
+    enabled && !providerScoped
+  );
+  if (providerScoped) {
+    if (manifestState.supportedLocales === void 0) {
+      return {
+        status: enabled ? QueryStatus.Loading : QueryStatus.Success,
+        data: void 0,
+        error: void 0,
+        isFetching: enabled,
+        refetch: fallback.refetch
+      };
+    }
+    return {
+      status: QueryStatus.Success,
+      data: manifestState.supportedLocales,
+      error: void 0,
+      isFetching: false,
+      refetch: fallback.refetch
+    };
+  }
+  return fallback;
+}
+function useQueryParam(name) {
+  const [value, setValue] = react.useState(() => readParam(name));
+  react.useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    installHistoryPatch();
+    setValue(readParam(name));
+    const handler = () => setValue(readParam(name));
+    window.addEventListener("popstate", handler);
+    window.addEventListener(PUSH_EVENT, handler);
+    window.addEventListener(REPLACE_EVENT, handler);
+    return () => {
+      window.removeEventListener("popstate", handler);
+      window.removeEventListener(PUSH_EVENT, handler);
+      window.removeEventListener(REPLACE_EVENT, handler);
+    };
+  }, [name]);
+  return value;
+}
+var PUSH_EVENT = "ppp:pushstate";
+var REPLACE_EVENT = "ppp:replacestate";
+var historyPatched = false;
+function installHistoryPatch() {
+  if (historyPatched) return;
+  if (typeof window === "undefined" || typeof window.history === "undefined") return;
+  historyPatched = true;
+  const origPush = window.history.pushState.bind(window.history);
+  const origReplace = window.history.replaceState.bind(window.history);
+  window.history.pushState = function(...args) {
+    origPush(...args);
+    window.dispatchEvent(new Event(PUSH_EVENT));
+  };
+  window.history.replaceState = function(...args) {
+    origReplace(...args);
+    window.dispatchEvent(new Event(REPLACE_EVENT));
+  };
+}
+function readParam(name) {
+  if (typeof window === "undefined") return null;
+  try {
+    const params = new URLSearchParams(window.location.search);
+    return params.get(name);
+  } catch {
+    return null;
+  }
+}
+function useBeforeUnloadWhen(condition) {
+  react.useEffect(() => {
+    if (!condition) return;
+    const handler = (e) => {
+      e.preventDefault();
+      e.returnValue = "";
+    };
+    window.addEventListener("beforeunload", handler);
+    return () => window.removeEventListener("beforeunload", handler);
+  }, [condition]);
+}
+var MainContextContext = react.createContext(null);
+MainContextContext.displayName = "MainContext";
+function MainContext({
+  children,
+  onBeforeSave,
+  warnOnUnsavedChanges,
+  forceSuccessfulValidationBeforeSave
+}) {
+  const parentMainContext = react.useContext(MainContextContext);
+  const isTopMost = parentMainContext === null;
+  const resolvedWarnOnUnsavedChanges = warnOnUnsavedChanges ?? parentMainContext?.warnOnUnsavedChanges ?? true;
+  const resolvedForceSuccessfulValidationBeforeSave = forceSuccessfulValidationBeforeSave ?? parentMainContext?.forceSuccessfulValidationBeforeSave ?? true;
+  const descendantsRef = react.useRef(/* @__PURE__ */ new Set());
+  const [version, setVersion] = react.useState(0);
+  const { ppp } = usePowerPortalsPro();
+  const refreshAll = react.useCallback(async () => {
+    for (const descendant of descendantsRef.current) {
+      await descendant.refresh();
+    }
+  }, []);
+  const resetState = react.useCallback(() => {
+    for (const descendant of descendantsRef.current) {
+      descendant.resetState();
+    }
+  }, []);
+  const validate = react.useCallback(async () => {
+    for (const descendant of descendantsRef.current) {
+      const ok = await descendant.validate();
+      if (!ok) return false;
+    }
+    return true;
+  }, []);
+  const saveAll = react.useCallback(async () => {
+    if (onBeforeSave) await onBeforeSave();
+    if (resolvedForceSuccessfulValidationBeforeSave) {
+      const valid = await validate();
+      if (!valid) return;
+    }
+    const requests = [];
+    for (const descendant of descendantsRef.current) {
+      requests.push(...descendant.getRequests());
+    }
+    if (requests.length === 0) return;
+    await ppp.executeMultipleAsync(requests, { returnResponses: false });
+    await refreshAll();
+  }, [onBeforeSave, validate, ppp, refreshAll, resolvedForceSuccessfulValidationBeforeSave]);
+  const registerDescendant = react.useCallback((descendant) => {
+    descendantsRef.current.add(descendant);
+    setVersion((v) => v + 1);
+    return () => {
+      descendantsRef.current.delete(descendant);
+      setVersion((v) => v + 1);
+    };
+  }, []);
+  const notifyDescendantDirtyChanged = react.useCallback(() => {
+    setVersion((v) => v + 1);
+  }, []);
+  const isDirty = react.useMemo(() => {
+    for (const descendant of descendantsRef.current) {
+      if (descendant.isDirty()) return true;
+    }
+    return false;
+  }, [version]);
+  const getRequests = react.useCallback(() => {
+    const all = [];
+    for (const descendant of descendantsRef.current) {
+      all.push(...descendant.getRequests());
+    }
+    return all;
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      saveAll,
+      refreshAll,
+      resetState,
+      validate,
+      getRequests,
+      registerDescendant,
+      notifyDescendantDirtyChanged,
+      isDirty,
+      warnOnUnsavedChanges: resolvedWarnOnUnsavedChanges,
+      forceSuccessfulValidationBeforeSave: resolvedForceSuccessfulValidationBeforeSave
+    }),
+    [
+      saveAll,
+      refreshAll,
+      resetState,
+      validate,
+      getRequests,
+      registerDescendant,
+      notifyDescendantDirtyChanged,
+      isDirty,
+      resolvedWarnOnUnsavedChanges,
+      resolvedForceSuccessfulValidationBeforeSave
+    ]
+  );
+  react.useEffect(() => {
+    if (!parentMainContext) return;
+    return parentMainContext.registerDescendant({
+      getRequests,
+      validate,
+      refresh: refreshAll,
+      resetState,
+      isDirty: () => isDirtyRef.current
+    });
+  }, [parentMainContext?.registerDescendant, getRequests, validate, refreshAll, resetState]);
+  const parentMainContextRef = react.useRef(parentMainContext);
+  parentMainContextRef.current = parentMainContext;
+  react.useEffect(() => {
+    parentMainContextRef.current?.notifyDescendantDirtyChanged();
+  }, [isDirty]);
+  useBeforeUnloadWhen(isTopMost && resolvedWarnOnUnsavedChanges && isDirty);
+  const unsavedChangesRegistry = useUnsavedChangesRegistry();
+  const isDirtyRef = react.useRef(isDirty);
+  isDirtyRef.current = isDirty;
+  const resolvedWarnRef = react.useRef(resolvedWarnOnUnsavedChanges);
+  resolvedWarnRef.current = resolvedWarnOnUnsavedChanges;
+  react.useEffect(() => {
+    if (!isTopMost) return;
+    if (!unsavedChangesRegistry) return;
+    return unsavedChangesRegistry.register({
+      isDirty: () => resolvedWarnRef.current && isDirtyRef.current
+    });
+  }, [isTopMost, unsavedChangesRegistry]);
+  react.useEffect(() => {
+    if (!isTopMost) return;
+    if (!unsavedChangesRegistry) return;
+    unsavedChangesRegistry.notifyDirtyChanged();
+  }, [isTopMost, unsavedChangesRegistry, isDirty, resolvedWarnOnUnsavedChanges]);
+  return /* @__PURE__ */ jsxRuntime.jsx(MainContextContext.Provider, { value, children });
+}
+function useMainContext() {
+  return react.useContext(MainContextContext);
+}
+function MainContextProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(MainContextContext.Provider, { value, children });
+}
+var OverlayContext = react.createContext(null);
+OverlayContext.displayName = "OverlayService";
+function useOverlayService() {
+  return react.useContext(OverlayContext)?.service ?? null;
+}
+function useOverlayForTarget(targetId) {
+  const ctx = react.useContext(OverlayContext);
+  if (!ctx) return null;
+  const stack = ctx.overlaysByTarget.get(targetId ?? "") ?? [];
+  return stack[stack.length - 1] ?? null;
+}
+function OverlayServiceProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(OverlayContext.Provider, { value, children });
+}
+function useOverlayServiceState() {
+  const [overlaysByTarget, setOverlaysByTarget] = react.useState(() => /* @__PURE__ */ new Map());
+  const nextIdRef = react.useRef(1);
+  const service = react.useMemo(
+    () => ({
+      show(options) {
+        const id = `overlay-${nextIdRef.current++}`;
+        const instance = { id, ...options };
+        setOverlaysByTarget((prev) => {
+          const key = options?.targetId ?? "";
+          const next = new Map(prev);
+          next.set(key, [...next.get(key) ?? [], instance]);
+          return next;
+        });
+        return instance;
+      },
+      hide(overlay) {
+        setOverlaysByTarget((prev) => {
+          const key = overlay.targetId ?? "";
+          const stack = prev.get(key) ?? [];
+          const idx = stack.findIndex((o) => o.id === overlay.id);
+          if (idx < 0) return prev;
+          const next = new Map(prev);
+          if (stack.length === 1) {
+            next.delete(key);
+          } else {
+            next.set(key, [...stack.slice(0, idx), ...stack.slice(idx + 1)]);
+          }
+          return next;
+        });
+      },
+      hideAll() {
+        setOverlaysByTarget(/* @__PURE__ */ new Map());
+      }
+    }),
+    []
+  );
+  return react.useMemo(() => ({ service, overlaysByTarget }), [service, overlaysByTarget]);
+}
+async function runWithOverlayAsync(service, options, operation) {
+  if (!service) return operation();
+  const handle = service.show(options);
+  try {
+    return await operation();
+  } finally {
+    service.hide(handle);
+  }
+}
+function useRunWithOverlay() {
+  const service = useOverlayService();
+  return react.useCallback(
+    (options, operation) => runWithOverlayAsync(service, options, operation),
+    [service]
+  );
+}
+var ValidationContextContext = react.createContext(null);
+ValidationContextContext.displayName = "ValidationContext";
+function useValidationContext() {
+  return react.useContext(ValidationContextContext);
+}
+function useColumnValidationErrors(columnName) {
+  const ctx = useValidationContext();
+  if (!ctx) return void 0;
+  return ctx.errors.get(columnName);
+}
+function ValidationProvider({ children }) {
+  const validatorsRef = react.useRef(/* @__PURE__ */ new Map());
+  const [errors, setErrors] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const register = react.useCallback(
+    (columnName, validator) => {
+      validatorsRef.current.set(columnName, validator);
+      return () => {
+        validatorsRef.current.delete(columnName);
+        setErrors((prev) => {
+          if (!prev.has(columnName)) return prev;
+          const next = new Map(prev);
+          next.delete(columnName);
+          return next;
+        });
+      };
+    },
+    []
+  );
+  const validateColumn = react.useCallback(async (columnName) => {
+    const validator = validatorsRef.current.get(columnName);
+    if (!validator) return;
+    const fieldErrors = await validator();
+    setErrors((prev) => {
+      const existing = prev.get(columnName) ?? [];
+      if (existing.length === fieldErrors.length && existing.every((e, i) => e === fieldErrors[i])) {
+        return prev;
+      }
+      const next = new Map(prev);
+      if (fieldErrors.length === 0) {
+        next.delete(columnName);
+      } else {
+        next.set(columnName, fieldErrors);
+      }
+      return next;
+    });
+  }, []);
+  const validateAll = react.useCallback(async () => {
+    const next = /* @__PURE__ */ new Map();
+    for (const [col, validator] of validatorsRef.current) {
+      const fieldErrors = await validator();
+      if (fieldErrors.length > 0) {
+        next.set(col, fieldErrors);
+      }
+    }
+    setErrors(next);
+    return next.size === 0;
+  }, []);
+  const clearErrors = react.useCallback(() => {
+    setErrors(/* @__PURE__ */ new Map());
+  }, []);
+  const isValid = errors.size === 0;
+  const value = react.useMemo(
+    () => ({ register, validateColumn, validateAll, clearErrors, isValid, errors }),
+    [register, validateColumn, validateAll, clearErrors, isValid, errors]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(ValidationContextContext.Provider, { value, children });
+}
+function valuesEqual(a, b) {
+  const aEmpty = a === null || a === void 0;
+  const bEmpty = b === null || b === void 0;
+  if (aEmpty && bEmpty) return true;
+  if (aEmpty !== bEmpty) return false;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+var GUID_PATTERN = /^\{?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}?$/i;
+function parseQueryDefault(metadata, rawValue) {
+  switch (metadata.$type) {
+    // StringMetadata + MemoMetadata both ride on StringValue. In Blazor
+    // MemoMetadata derives from StringMetadata so a single `StringMetadata`
+    // pattern catches both; in TS the discriminators are distinct so we
+    // list both arms.
+    case 14:
+    case 7:
+      return { $type: 14, value: rawValue };
+    case 5: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) && Number.isInteger(n) ? { $type: 5, value: n } : null;
+    }
+    case 18: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) && Number.isInteger(n) ? { $type: 18, value: n } : null;
+    }
+    case 3: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) ? { $type: 3, value: n } : null;
+    }
+    case 4: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) ? { $type: 4, value: n } : null;
+    }
+    case 8: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) ? { $type: 8, value: n } : null;
+    }
+    case 0: {
+      const lower = rawValue.trim().toLowerCase();
+      if (lower === "true") return { $type: 0, value: true };
+      if (lower === "false") return { $type: 0, value: false };
+      return null;
+    }
+    case 2: {
+      const ts = Date.parse(rawValue);
+      if (Number.isNaN(ts)) return null;
+      return { $type: 2, value: new Date(ts).toISOString() };
+    }
+    case 11: {
+      const n = Number(rawValue);
+      return Number.isFinite(n) && Number.isInteger(n) ? { $type: 11, value: n } : null;
+    }
+    case 40: {
+      const parts = rawValue.split(",").map((s) => s.trim()).filter(Boolean);
+      const values = [];
+      for (const p of parts) {
+        const n = Number(p);
+        if (Number.isFinite(n) && Number.isInteger(n)) values.push({ value: n });
+      }
+      return values.length > 0 ? { $type: 40, value: values } : null;
+    }
+    case 6: {
+      try {
+        const parsed = JSON.parse(rawValue);
+        if (!parsed || typeof parsed !== "object") return null;
+        const findKey = (target) => Object.keys(parsed).find(
+          (k) => k.toLowerCase() === target.toLowerCase()
+        );
+        const obj = parsed;
+        const tableNameKey = findKey("tableName");
+        const valueKey = findKey("value");
+        const nameKey = findKey("name");
+        const tableName = tableNameKey ? obj[tableNameKey] : void 0;
+        const value = valueKey ? obj[valueKey] : void 0;
+        const name = nameKey ? obj[nameKey] : null;
+        if (typeof tableName !== "string" || tableName.length === 0) return null;
+        if (typeof value !== "string" || value.length === 0) return null;
+        return {
+          $type: 6,
+          tableName,
+          value,
+          name: typeof name === "string" ? name : null
+        };
+      } catch {
+        return null;
+      }
+    }
+    case 15: {
+      if (!GUID_PATTERN.test(rawValue)) return null;
+      return { $type: 15, value: rawValue.replace(/[{}]/g, "") };
+    }
+    default:
+      return null;
+  }
+}
+function parseQueryDefaultsFromUrl(search, tableMetadata) {
+  const out = {};
+  if (!search) return out;
+  const params = new URLSearchParams(search);
+  for (const [columnName, rawValue] of params) {
+    if (!columnName) continue;
+    const meta = tableMetadata.columns.find(
+      (c) => c.columnName === columnName
+    );
+    if (!meta) continue;
+    try {
+      const parsed = parseQueryDefault(meta, rawValue);
+      if (parsed) out[columnName] = parsed;
+    } catch {
+    }
+  }
+  return out;
+}
+var RecordContextContext = react.createContext(null);
+RecordContextContext.displayName = "RecordContext";
+function RecordContext(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(ValidationProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(RecordContextInner, { ...props }) });
+}
+function RecordContextInner({
+  children,
+  table,
+  id: idProp,
+  queryParameterName,
+  initialRecord,
+  loadedRecord: loadedRecordProp,
+  initialPendingChanges,
+  columns,
+  onRecordLoaded,
+  onBeforeSave,
+  onBeforeDelete,
+  warnOnUnsavedChanges,
+  forceSuccessfulValidationBeforeSave
+}) {
+  const queryId = useQueryParam(queryParameterName ?? "");
+  const resolvedId = queryParameterName && queryId !== null && queryId.length > 0 ? queryId : idProp;
+  const propIsEmptyId = !resolvedId || resolvedId === "00000000-0000-0000-0000-000000000000";
+  const [effectiveId, setEffectiveId] = react.useState(
+    propIsEmptyId ? void 0 : resolvedId
+  );
+  react.useEffect(() => {
+    setEffectiveId(propIsEmptyId ? void 0 : resolvedId);
+  }, [resolvedId, propIsEmptyId]);
+  const isCreateMode = effectiveId === void 0;
+  const isSkipFetchMode = !isCreateMode && loadedRecordProp !== void 0;
+  const { ppp } = usePowerPortalsPro();
+  const mainContext = useMainContext();
+  const validation = useValidationContext();
+  const isTopMost = mainContext === null;
+  const resolvedWarnOnUnsavedChanges = warnOnUnsavedChanges ?? mainContext?.warnOnUnsavedChanges ?? true;
+  const resolvedForceSuccessfulValidationBeforeSave = forceSuccessfulValidationBeforeSave ?? mainContext?.forceSuccessfulValidationBeforeSave ?? true;
+  const overlayService = useOverlayService();
+  const localizer = useLocalizer();
+  const overlayTargetId = react.useId();
+  const query = useRecord(table, effectiveId ?? "", {
+    ...columns ? { columns } : {},
+    enabled: !isCreateMode && !isSkipFetchMode
+  });
+  const metadataQuery = useTableMetadata(table);
+  const [loadedRecord, setLoadedRecord] = react.useState(
+    () => isSkipFetchMode ? loadedRecordProp : void 0
+  );
+  const [pendingChanges, setPendingChanges] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const onRecordLoadedRef = react.useRef(onRecordLoaded);
+  onRecordLoadedRef.current = onRecordLoaded;
+  const onBeforeSaveRef = react.useRef(onBeforeSave);
+  onBeforeSaveRef.current = onBeforeSave;
+  const refetchRef = react.useRef(query.refetch);
+  refetchRef.current = query.refetch;
+  const recordRef = react.useRef(void 0);
+  const loadedRecordRef = react.useRef(void 0);
+  const ownDirtyRef = react.useRef(false);
+  const pendingChangesRef = react.useRef(/* @__PURE__ */ new Map());
+  pendingChangesRef.current = pendingChanges;
+  const validationRef = react.useRef(validation);
+  validationRef.current = validation;
+  const isCreateModeRef = react.useRef(isCreateMode);
+  isCreateModeRef.current = isCreateMode;
+  const forceSuccessfulValidationBeforeSaveRef = react.useRef(
+    resolvedForceSuccessfulValidationBeforeSave
+  );
+  forceSuccessfulValidationBeforeSaveRef.current = resolvedForceSuccessfulValidationBeforeSave;
+  const queryParameterNameRef = react.useRef(queryParameterName);
+  queryParameterNameRef.current = queryParameterName;
+  const isTopMostRef = react.useRef(mainContext === null);
+  isTopMostRef.current = mainContext === null;
+  react.useEffect(() => {
+    if (!isCreateMode) return;
+    const baseSeed = initialRecord ?? { tableName: table, properties: {} };
+    const seeded = baseSeed.id !== void 0 ? baseSeed : { ...baseSeed, _idForCreate: crypto.randomUUID() };
+    setLoadedRecord(seeded);
+    setPendingChanges(/* @__PURE__ */ new Map());
+  }, [isCreateMode, initialRecord, table]);
+  react.useEffect(() => {
+    if (!isCreateMode) return;
+    if (!queryParameterName) return;
+    if (!metadataQuery.data) return;
+    if (!loadedRecord) return;
+    if (pendingChangesRef.current.size > 0) return;
+    const search = typeof window !== "undefined" ? window.location.search : "";
+    const defaults = parseQueryDefaultsFromUrl(search, metadataQuery.data);
+    const cols = Object.keys(defaults);
+    if (cols.length === 0) return;
+    let changed = false;
+    const nextProperties = {
+      ...loadedRecord.properties ?? {}
+    };
+    for (const col of cols) {
+      const next = defaults[col];
+      if (!valuesEqual(nextProperties[col], next)) {
+        nextProperties[col] = next;
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    setLoadedRecord(
+      (current) => current ? { ...current, properties: nextProperties } : current
+    );
+  }, [isCreateMode, queryParameterName, metadataQuery.data, loadedRecord]);
+  react.useEffect(() => {
+    if (!isSkipFetchMode || !loadedRecordProp) return;
+    setLoadedRecord(loadedRecordProp);
+    setPendingChanges(
+      initialPendingChanges && initialPendingChanges.size > 0 ? new Map(initialPendingChanges) : /* @__PURE__ */ new Map()
+    );
+    validationRef.current?.clearErrors();
+    onRecordLoadedRef.current?.(loadedRecordProp);
+  }, [isSkipFetchMode, loadedRecordProp, initialPendingChanges]);
+  react.useEffect(() => {
+    if (query.status === "success" && query.data) {
+      setLoadedRecord(query.data);
+      setPendingChanges(
+        initialPendingChanges && initialPendingChanges.size > 0 ? new Map(initialPendingChanges) : /* @__PURE__ */ new Map()
+      );
+      validationRef.current?.clearErrors();
+      onRecordLoadedRef.current?.(query.data);
+    }
+  }, [query.status, query.data, initialPendingChanges]);
+  loadedRecordRef.current = loadedRecord;
+  const record = react.useMemo(() => {
+    if (!loadedRecord) return void 0;
+    if (pendingChanges.size === 0) return loadedRecord;
+    const properties = { ...loadedRecord.properties ?? {} };
+    for (const [col, val] of pendingChanges) {
+      if (val === null) {
+        delete properties[col];
+      } else {
+        properties[col] = val;
+      }
+    }
+    return { ...loadedRecord, properties, isDirty: true };
+  }, [loadedRecord, pendingChanges]);
+  const dirtyColumns = react.useMemo(
+    () => new Set(pendingChanges.keys()),
+    [pendingChanges]
+  );
+  const ownDirty = pendingChanges.size > 0;
+  recordRef.current = record;
+  ownDirtyRef.current = ownDirty;
+  const nestedRef = react.useRef(/* @__PURE__ */ new Set());
+  const [nestedVersion, setNestedVersion] = react.useState(0);
+  const nestedDirty = react.useMemo(() => {
+    for (const d of nestedRef.current) {
+      if (d.isDirty()) return true;
+    }
+    return false;
+  }, [nestedVersion]);
+  const isDirty = ownDirty || nestedDirty;
+  const registerNested = react.useCallback((descendant) => {
+    nestedRef.current.add(descendant);
+    setNestedVersion((v) => v + 1);
+    return () => {
+      nestedRef.current.delete(descendant);
+      setNestedVersion((v) => v + 1);
+    };
+  }, []);
+  const notifyNestedDirtyChanged = react.useCallback(() => {
+    setNestedVersion((v) => v + 1);
+  }, []);
+  const buildOwnSaveRequest = react.useCallback(() => {
+    if (!recordRef.current || !ownDirtyRef.current) return null;
+    const current = recordRef.current;
+    if (isCreateModeRef.current) {
+      const allProperties = {
+        ...current.properties
+      };
+      return {
+        $type: "CreateRequest",
+        record: {
+          tableName: current.tableName,
+          // Include the client-pre-generated GUID. The seed effect writes
+          // it into `_idForCreate` (Blazor parity); the server's in-batch
+          // resolver matches AssociateRequest / child-FK references
+          // against either `id` or `_idForCreate`, so a Create + Associate
+          // pair within one `ExecuteMultiple` resolves to the same record.
+          // `id` is also forwarded when the consumer supplied an explicit
+          // one via `initialRecord` (rare — pre-assigned ids on data
+          // import).
+          ...current.id !== void 0 && { id: current.id },
+          ...current._idForCreate !== void 0 && current._idForCreate !== null && {
+            _idForCreate: current._idForCreate
+          },
+          properties: allProperties
+        }
+      };
+    }
+    const partialProperties = {};
+    for (const [col, val] of pendingChangesRef.current) {
+      partialProperties[col] = val;
+    }
+    const partialRecord = {
+      tableName: current.tableName,
+      properties: partialProperties,
+      ...current.id !== void 0 && { id: current.id }
+    };
+    return { $type: "UpdateRequest", record: partialRecord };
+  }, []);
+  const getRequests = react.useCallback(() => {
+    const all = [];
+    const own = buildOwnSaveRequest();
+    if (own) all.push(own);
+    for (const descendant of nestedRef.current) {
+      all.push(...descendant.getRequests());
+    }
+    return all;
+  }, [buildOwnSaveRequest]);
+  const validate = react.useCallback(async () => {
+    for (const descendant of nestedRef.current) {
+      if (!await descendant.validate()) return false;
+    }
+    return true;
+  }, []);
+  const saveAll = react.useCallback(async () => {
+    if (!loadedRecordRef.current) {
+      throw new Error("RecordContext.save called before the record loaded.");
+    }
+    await onBeforeSaveRef.current?.();
+    if (forceSuccessfulValidationBeforeSaveRef.current) {
+      const valid = await validate();
+      if (!valid) return;
+    }
+    const ownReq = buildOwnSaveRequest();
+    const descendantReqs = [];
+    for (const descendant of nestedRef.current) {
+      descendantReqs.push(...descendant.getRequests());
+    }
+    const requests = ownReq ? [ownReq, ...descendantReqs] : descendantReqs;
+    if (requests.length > 0) {
+      const responses = await ppp.executeMultipleAsync(requests, { returnResponses: true });
+      if (ownReq?.$type === "CreateRequest") {
+        const ownResp = responses[0];
+        if (ownResp?.$type === "CreateResponse" && ownResp.id) {
+          setEffectiveId(ownResp.id);
+          const qpn = queryParameterNameRef.current;
+          if (qpn && isTopMostRef.current && typeof window !== "undefined") {
+            const existing = new URLSearchParams(window.location.search).get(
+              qpn
+            );
+            if (!existing) {
+              const newUrl = new URL(window.location.href);
+              newUrl.searchParams.set(qpn, ownResp.id);
+              window.history.replaceState(
+                window.history.state,
+                "",
+                newUrl.toString()
+              );
+            }
+          }
+        }
+      }
+      setPendingChanges(/* @__PURE__ */ new Map());
+    }
+    if (!isCreateModeRef.current) {
+      void refetchRef.current();
+    }
+    for (const descendant of nestedRef.current) {
+      await descendant.refresh();
+    }
+  }, [ppp, validate, buildOwnSaveRequest]);
+  const reload = react.useCallback(async () => {
+    refetchRef.current();
+    for (const descendant of nestedRef.current) {
+      await descendant.refresh();
+    }
+  }, []);
+  const resetState = react.useCallback(() => {
+    setPendingChanges(/* @__PURE__ */ new Map());
+    validationRef.current?.clearErrors();
+    for (const descendant of nestedRef.current) {
+      descendant.resetState();
+    }
+  }, []);
+  const setColumnValue = react.useCallback(
+    (columnName, value2) => {
+      setPendingChanges((prev) => {
+        if (!loadedRecord) return prev;
+        const original = loadedRecord.properties?.[columnName];
+        const newValue = value2 ?? null;
+        if (valuesEqual(original, newValue)) {
+          if (!prev.has(columnName)) return prev;
+          const next2 = new Map(prev);
+          next2.delete(columnName);
+          return next2;
+        }
+        const existing = prev.has(columnName) ? prev.get(columnName) ?? null : void 0;
+        if (existing !== void 0 && valuesEqual(existing, newValue)) return prev;
+        const next = new Map(prev);
+        next.set(columnName, newValue);
+        return next;
+      });
+    },
+    [loadedRecord]
+  );
+  const hydrateColumnValue = react.useCallback(
+    (columnName, value2) => {
+      setLoadedRecord((current) => {
+        if (!current) return current;
+        if (pendingChanges.has(columnName)) return current;
+        const previous = current.properties?.[columnName];
+        if (value2 === null) {
+          if (previous === void 0) return current;
+          const nextProperties = { ...current.properties ?? {} };
+          delete nextProperties[columnName];
+          return { ...current, properties: nextProperties };
+        }
+        if (valuesEqual(previous, value2)) return current;
+        return {
+          ...current,
+          properties: { ...current.properties ?? {}, [columnName]: value2 }
+        };
+      });
+    },
+    [pendingChanges]
+  );
+  const loadingOverlayRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!overlayService) return;
+    if (query.status === "loading") {
+      if (!loadingOverlayRef.current) {
+        loadingOverlayRef.current = overlayService.show({
+          targetId: overlayTargetId,
+          description: localizer.t("app.messages.record-loading")
+        });
+      }
+    } else if (loadingOverlayRef.current) {
+      overlayService.hide(loadingOverlayRef.current);
+      loadingOverlayRef.current = null;
+    }
+    return () => {
+      if (loadingOverlayRef.current) {
+        overlayService.hide(loadingOverlayRef.current);
+        loadingOverlayRef.current = null;
+      }
+    };
+  }, [overlayService, query.status, overlayTargetId, localizer]);
+  const isDirtyRef = react.useRef(isDirty);
+  isDirtyRef.current = isDirty;
+  const mainContextRef = react.useRef(mainContext);
+  mainContextRef.current = mainContext;
+  react.useEffect(() => {
+    if (!mainContext) return;
+    return mainContext.registerDescendant({
+      getRequests,
+      validate,
+      refresh: reload,
+      resetState,
+      isDirty: () => isDirtyRef.current
+    });
+  }, [mainContext?.registerDescendant, getRequests, validate, reload, resetState]);
+  react.useEffect(() => {
+    mainContextRef.current?.notifyDescendantDirtyChanged();
+  }, [isDirty]);
+  useBeforeUnloadWhen(isTopMost && resolvedWarnOnUnsavedChanges && isDirty);
+  const unsavedChangesRegistry = useUnsavedChangesRegistry();
+  const resolvedWarnRef = react.useRef(resolvedWarnOnUnsavedChanges);
+  resolvedWarnRef.current = resolvedWarnOnUnsavedChanges;
+  react.useEffect(() => {
+    if (!isTopMost) return;
+    if (!unsavedChangesRegistry) return;
+    return unsavedChangesRegistry.register({
+      isDirty: () => resolvedWarnRef.current && isDirtyRef.current
+    });
+  }, [isTopMost, unsavedChangesRegistry]);
+  react.useEffect(() => {
+    if (!isTopMost) return;
+    if (!unsavedChangesRegistry) return;
+    unsavedChangesRegistry.notifyDirtyChanged();
+  }, [isTopMost, unsavedChangesRegistry, isDirty, resolvedWarnOnUnsavedChanges]);
+  const innerMainContext = react.useMemo(
+    () => ({
+      saveAll,
+      refreshAll: reload,
+      resetState,
+      validate,
+      getRequests,
+      registerDescendant: registerNested,
+      notifyDescendantDirtyChanged: notifyNestedDirtyChanged,
+      isDirty,
+      warnOnUnsavedChanges: resolvedWarnOnUnsavedChanges,
+      forceSuccessfulValidationBeforeSave: resolvedForceSuccessfulValidationBeforeSave
+    }),
+    [
+      saveAll,
+      reload,
+      resetState,
+      validate,
+      getRequests,
+      registerNested,
+      notifyNestedDirtyChanged,
+      isDirty,
+      resolvedWarnOnUnsavedChanges,
+      resolvedForceSuccessfulValidationBeforeSave
+    ]
+  );
+  const onBeforeDeleteRef = react.useRef(onBeforeDelete);
+  onBeforeDeleteRef.current = onBeforeDelete;
+  const runBeforeDelete = react.useCallback(async () => {
+    const handler = onBeforeDeleteRef.current;
+    if (handler) await handler();
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      status: query.status,
+      record,
+      error: query.error,
+      reload,
+      save: saveAll,
+      getRequests,
+      resetState,
+      setColumnValue,
+      hydrateColumnValue,
+      tableMetadata: metadataQuery.data,
+      isDirty,
+      dirtyColumns,
+      overlayTargetId,
+      runBeforeDelete
+    }),
+    [
+      query.status,
+      query.error,
+      record,
+      reload,
+      saveAll,
+      getRequests,
+      resetState,
+      setColumnValue,
+      hydrateColumnValue,
+      metadataQuery.data,
+      isDirty,
+      dirtyColumns,
+      overlayTargetId,
+      runBeforeDelete
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MainContextProvider, { value: innerMainContext, children: /* @__PURE__ */ jsxRuntime.jsx(RecordContextContext.Provider, { value, children }) });
+}
+function useRecordContext() {
+  const ctx = react.useContext(RecordContextContext);
+  if (!ctx) {
+    throw new Error(
+      "useRecordContext must be used inside <RecordContext>. Wrap the component tree where you need the record."
+    );
+  }
+  return ctx;
+}
+function useRecordContextOptional() {
+  return react.useContext(RecordContextContext);
+}
+var EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
+function LookupRecordContext({
+  columnName,
+  onBeforeSave,
+  children,
+  isVisible = true
+}) {
+  const parent = useRecordContext();
+  if (!isVisible) return null;
+  const raw = parent.record?.properties?.[columnName];
+  if (!raw?.value || raw.value === EMPTY_GUID || !raw.tableName) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    RecordContext,
+    {
+      table: raw.tableName,
+      id: raw.value,
+      ...onBeforeSave && { onBeforeSave },
+      children
+    }
+  );
+}
+
+// src/use-column-metadata.ts
+function useColumnMetadata(columnName) {
+  const { tableMetadata } = useRecordContext();
+  return tableMetadata?.columns.find((c) => c.columnName === columnName);
+}
+var DialogServiceContext = react.createContext(null);
+DialogServiceContext.displayName = "DialogService";
+function useDialogService() {
+  const ctx = react.useContext(DialogServiceContext);
+  if (!ctx) {
+    throw new Error(
+      "useDialogService must be used inside a <DialogServiceProvider>. Wrap your app in <FluentDialogProvider> from @powerportalspro/react-fluent (or your own implementation) so framework dialogs have somewhere to render."
+    );
+  }
+  return ctx;
+}
+function DialogServiceProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(DialogServiceContext.Provider, { value, children });
+}
+async function warnAboutUnsavedChangesAsync(dialog, localizer) {
+  const result = await dialog.showConfirmationAsync(localizer.t("app.messages.unsaved-changes"), {
+    title: localizer.t("app.messages.unsaved-changes-title"),
+    primaryText: localizer.t("app.buttons.yes.label"),
+    secondaryText: localizer.t("app.buttons.no.label")
+  });
+  return !result.cancelled;
+}
+function useWarnAboutUnsavedChanges() {
+  const dialog = useDialogService();
+  const localizer = useLocalizer();
+  return react.useCallback(
+    () => warnAboutUnsavedChangesAsync(dialog, localizer),
+    [dialog, localizer]
+  );
+}
+
+// src/unsaved-changes-warning.ts
+function useUnsavedChangesWarning() {
+  const ctx = useMainContext();
+  const isDirty = ctx?.isDirty ?? false;
+  useBeforeUnloadWhen(isDirty);
+}
+function useUnsavedChangesGuard() {
+  const isAnyDirty = useIsAnyDirty();
+  const warn = useWarnAboutUnsavedChanges();
+  return { isAnyDirty, warn };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+exports.ASP_NET_CULTURE_COOKIE = ASP_NET_CULTURE_COOKIE;
+exports.AuthStatus = AuthStatus;
+exports.AuthorizedView = AuthorizedView;
+exports.DEFAULT_URL_LOCALE_PATTERN = DEFAULT_URL_LOCALE_PATTERN;
+exports.DefaultLocalizerProvider = DefaultLocalizerProvider;
+exports.DialogServiceProvider = DialogServiceProvider;
+exports.InMemoryEnvironmentFileSettingsCache = InMemoryEnvironmentFileSettingsCache;
+exports.InMemoryTableMetadataCache = InMemoryTableMetadataCache;
+exports.InMemoryViewMetadataCache = InMemoryViewMetadataCache;
+exports.InMemoryViewsForTableCache = InMemoryViewsForTableCache;
+exports.LocaleProvider = LocaleProvider;
+exports.LocalizerProvider = LocalizerProvider;
+exports.LookupRecordContext = LookupRecordContext;
+exports.MainContext = MainContext;
+exports.MainContextProvider = MainContextProvider;
+exports.OverlayServiceProvider = OverlayServiceProvider;
+exports.PowerPortalsProContext = PowerPortalsProContext;
+exports.PowerPortalsProProvider = PowerPortalsProProvider;
+exports.QueryStatus = QueryStatus;
+exports.RecordContext = RecordContext;
+exports.UnsavedChangesRegistryProvider = UnsavedChangesRegistryProvider;
+exports.VERSION = VERSION;
+exports.ValidationProvider = ValidationProvider;
+exports.createLocalizer = createLocalizer;
+exports.detectLocale = detectLocale;
+exports.flattenStrings = flattenStrings;
+exports.getAspNetCultureCookie = getAspNetCultureCookie;
+exports.getLocaleFromUrlPath = getLocaleFromUrlPath;
+exports.interpolate = interpolate;
+exports.resolveLocalizationUrl = resolveLocalizationUrl;
+exports.runWithOverlayAsync = runWithOverlayAsync;
+exports.setAspNetCultureCookie = setAspNetCultureCookie;
+exports.useAuth = useAuth;
+exports.useColumnMetadata = useColumnMetadata;
+exports.useColumnValidationErrors = useColumnValidationErrors;
+exports.useDialogService = useDialogService;
+exports.useEnvironmentFileSettings = useEnvironmentFileSettings;
+exports.useFetchRecords = useFetchRecords;
+exports.useGridData = useGridData;
+exports.useIsAnyDirty = useIsAnyDirty;
+exports.useLocale = useLocale;
+exports.useLocalization = useLocalization;
+exports.useLocalizationLoaded = useLocalizationLoaded;
+exports.useLocalizationPrefetcher = useLocalizationPrefetcher;
+exports.useLocalizer = useLocalizer;
+exports.useMainContext = useMainContext;
+exports.useOverlayForTarget = useOverlayForTarget;
+exports.useOverlayService = useOverlayService;
+exports.useOverlayServiceState = useOverlayServiceState;
+exports.usePowerPortalsPro = usePowerPortalsPro;
+exports.usePrefixedT = usePrefixedT;
+exports.useQueryParam = useQueryParam;
+exports.useRecord = useRecord;
+exports.useRecordContext = useRecordContext;
+exports.useRecordContextOptional = useRecordContextOptional;
+exports.useRunWithOverlay = useRunWithOverlay;
+exports.useSupportedLocales = useSupportedLocales;
+exports.useT = useT;
+exports.useTableMetadata = useTableMetadata;
+exports.useTablePermissions = useTablePermissions;
+exports.useUnsavedChangesGuard = useUnsavedChangesGuard;
+exports.useUnsavedChangesRegistry = useUnsavedChangesRegistry;
+exports.useUnsavedChangesWarning = useUnsavedChangesWarning;
+exports.useValidationContext = useValidationContext;
+exports.useViewDataSource = useViewDataSource;
+exports.useViewMetadata = useViewMetadata;
+exports.useViewsForTable = useViewsForTable;
+exports.useWarnAboutUnsavedChanges = useWarnAboutUnsavedChanges;
+exports.warnAboutUnsavedChangesAsync = warnAboutUnsavedChangesAsync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map