@gaddario98/react-core 2.0.0 → 2.0.2

package/dist/pages/index.js

@@ -1 +1,4652 @@
-'use strict';var reactPages=require('@gaddario98/react-pages');Object.keys(reactPages).forEach(function(k){if(k!=='default'&&!Object.prototype.hasOwnProperty.call(exports,k))Object.defineProperty(exports,k,{enumerable:true,get:function(){return reactPages[k]}})});//# sourceMappingURL=index.js.map
+'use strict';var jsxRuntime=require('react/jsx-runtime'),React=require('react'),reactQueries=require('@gaddario98/react-queries'),compilerRuntime=require('react/compiler-runtime'),reactState=require('@gaddario98/react-state'),equal=require('fast-deep-equal'),reactForm=require('@gaddario98/react-form');/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};function hasInitialValue(atom) {
+  return "init" in atom;
+}
+function isActuallyWritableAtom(atom) {
+  return !!atom.write;
+}
+function isAtomStateInitialized(atomState) {
+  return "v" in atomState || "e" in atomState;
+}
+function returnAtomValue(atomState) {
+  if ("e" in atomState) {
+    throw atomState.e;
+  }
+  if ((undefined ? undefined.MODE : void 0) !== "production" && !("v" in atomState)) {
+    throw new Error("[Bug] atom state is not initialized");
+  }
+  return atomState.v;
+}
+const promiseStateMap = /* @__PURE__ */ new WeakMap();
+function isPendingPromise(value) {
+  var _a;
+  return isPromiseLike$1(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
+}
+function abortPromise(promise) {
+  const promiseState = promiseStateMap.get(promise);
+  if (promiseState == null ? void 0 : promiseState[0]) {
+    promiseState[0] = false;
+    promiseState[1].forEach((fn) => fn());
+  }
+}
+function registerAbortHandler(promise, abortHandler) {
+  let promiseState = promiseStateMap.get(promise);
+  if (!promiseState) {
+    promiseState = [true, /* @__PURE__ */ new Set()];
+    promiseStateMap.set(promise, promiseState);
+    const settle = () => {
+      promiseState[0] = false;
+    };
+    promise.then(settle, settle);
+  }
+  promiseState[1].add(abortHandler);
+}
+function isPromiseLike$1(p) {
+  return typeof (p == null ? void 0 : p.then) === "function";
+}
+function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
+  if (!dependencyAtomState.p.has(atom)) {
+    dependencyAtomState.p.add(atom);
+    const cleanup = () => dependencyAtomState.p.delete(atom);
+    promise.then(cleanup, cleanup);
+  }
+}
+function getMountedOrPendingDependents(atom, atomState, mountedMap) {
+  var _a;
+  const dependents = /* @__PURE__ */ new Set();
+  for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
+    dependents.add(a);
+  }
+  for (const atomWithPendingPromise of atomState.p) {
+    dependents.add(atomWithPendingPromise);
+  }
+  return dependents;
+}
+const atomRead = (_store, atom, ...params) => atom.read(...params);
+const atomWrite = (_store, atom, ...params) => atom.write(...params);
+const atomOnInit = (store, atom) => {
+  if (atom.INTERNAL_onInit) {
+    return atom.INTERNAL_onInit(store);
+  }
+  if (atom.unstable_onInit) {
+    console.warn(
+      "[DEPRECATED] atom.unstable_onInit is renamed to atom.INTERNAL_onInit."
+    );
+    return atom.unstable_onInit(store);
+  }
+};
+const atomOnMount = (_store, atom, setAtom) => {
+  var _a;
+  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
+};
+const ensureAtomState = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const atomStateMap = buildingBlocks[0];
+  const storeHooks = buildingBlocks[6];
+  const atomOnInit2 = buildingBlocks[9];
+  if ((undefined ? undefined.MODE : void 0) !== "production" && !atom) {
+    throw new Error("Atom is undefined or null");
+  }
+  let atomState = atomStateMap.get(atom);
+  if (!atomState) {
+    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
+    atomStateMap.set(atom, atomState);
+    (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
+    atomOnInit2 == null ? void 0 : atomOnInit2(store, atom);
+  }
+  return atomState;
+};
+const flushCallbacks = (store) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const changedAtoms = buildingBlocks[3];
+  const mountCallbacks = buildingBlocks[4];
+  const unmountCallbacks = buildingBlocks[5];
+  const storeHooks = buildingBlocks[6];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const errors = [];
+  const call = (fn) => {
+    try {
+      fn();
+    } catch (e) {
+      errors.push(e);
+    }
+  };
+  do {
+    if (storeHooks.f) {
+      call(storeHooks.f);
+    }
+    const callbacks = /* @__PURE__ */ new Set();
+    const add = callbacks.add.bind(callbacks);
+    changedAtoms.forEach((atom) => {
+      var _a;
+      return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
+    });
+    changedAtoms.clear();
+    unmountCallbacks.forEach(add);
+    unmountCallbacks.clear();
+    mountCallbacks.forEach(add);
+    mountCallbacks.clear();
+    callbacks.forEach(call);
+    if (changedAtoms.size) {
+      recomputeInvalidatedAtoms2(store);
+    }
+  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+  if (errors.length) {
+    throw new AggregateError(errors);
+  }
+};
+const recomputeInvalidatedAtoms = (store) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const changedAtoms = buildingBlocks[3];
+  const ensureAtomState2 = buildingBlocks[11];
+  const readAtomState2 = buildingBlocks[14];
+  const mountDependencies2 = buildingBlocks[17];
+  const topSortedReversed = [];
+  const visiting = /* @__PURE__ */ new WeakSet();
+  const visited = /* @__PURE__ */ new WeakSet();
+  const stack = Array.from(changedAtoms);
+  while (stack.length) {
+    const a = stack[stack.length - 1];
+    const aState = ensureAtomState2(store, a);
+    if (visited.has(a)) {
+      stack.pop();
+      continue;
+    }
+    if (visiting.has(a)) {
+      if (invalidatedAtoms.get(a) === aState.n) {
+        topSortedReversed.push([a, aState]);
+      } else if ((undefined ? undefined.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) {
+        throw new Error("[Bug] invalidated atom exists");
+      }
+      visited.add(a);
+      stack.pop();
+      continue;
+    }
+    visiting.add(a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      if (!visiting.has(d)) {
+        stack.push(d);
+      }
+    }
+  }
+  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
+    const [a, aState] = topSortedReversed[i];
+    let hasChangedDeps = false;
+    for (const dep of aState.d.keys()) {
+      if (dep !== a && changedAtoms.has(dep)) {
+        hasChangedDeps = true;
+        break;
+      }
+    }
+    if (hasChangedDeps) {
+      readAtomState2(store, a);
+      mountDependencies2(store, a);
+    }
+    invalidatedAtoms.delete(a);
+  }
+};
+const storeMutationSet = /* @__PURE__ */ new WeakSet();
+const readAtomState = (store, atom) => {
+  var _a, _b;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const atomRead2 = buildingBlocks[7];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const writeAtomState2 = buildingBlocks[16];
+  const mountDependencies2 = buildingBlocks[17];
+  const atomState = ensureAtomState2(store, atom);
+  if (isAtomStateInitialized(atomState)) {
+    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
+      return atomState;
+    }
+    let hasChangedDeps = false;
+    for (const [a, n] of atomState.d) {
+      if (readAtomState2(store, a).n !== n) {
+        hasChangedDeps = true;
+        break;
+      }
+    }
+    if (!hasChangedDeps) {
+      return atomState;
+    }
+  }
+  atomState.d.clear();
+  let isSync = true;
+  function mountDependenciesIfAsync() {
+    if (mountedMap.has(atom)) {
+      mountDependencies2(store, atom);
+      recomputeInvalidatedAtoms2(store);
+      flushCallbacks2(store);
+    }
+  }
+  function getter(a) {
+    var _a2;
+    if (a === atom) {
+      const aState2 = ensureAtomState2(store, a);
+      if (!isAtomStateInitialized(aState2)) {
+        if (hasInitialValue(a)) {
+          setAtomStateValueOrPromise(store, a, a.init);
+        } else {
+          throw new Error("no atom init");
+        }
+      }
+      return returnAtomValue(aState2);
+    }
+    const aState = readAtomState2(store, a);
+    try {
+      return returnAtomValue(aState);
+    } finally {
+      atomState.d.set(a, aState.n);
+      if (isPendingPromise(atomState.v)) {
+        addPendingPromiseToDependency(atom, atomState.v, aState);
+      }
+      if (mountedMap.has(atom)) {
+        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
+      }
+      if (!isSync) {
+        mountDependenciesIfAsync();
+      }
+    }
+  }
+  let controller;
+  let setSelf;
+  const options = {
+    get signal() {
+      if (!controller) {
+        controller = new AbortController();
+      }
+      return controller.signal;
+    },
+    get setSelf() {
+      if ((undefined ? undefined.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
+        console.warn("setSelf function cannot be used with read-only atom");
+      }
+      if (!setSelf && isActuallyWritableAtom(atom)) {
+        setSelf = (...args) => {
+          if ((undefined ? undefined.MODE : void 0) !== "production" && isSync) {
+            console.warn("setSelf function cannot be called in sync");
+          }
+          if (!isSync) {
+            try {
+              return writeAtomState2(store, atom, ...args);
+            } finally {
+              recomputeInvalidatedAtoms2(store);
+              flushCallbacks2(store);
+            }
+          }
+        };
+      }
+      return setSelf;
+    }
+  };
+  const prevEpochNumber = atomState.n;
+  try {
+    if ((undefined ? undefined.MODE : void 0) !== "production") {
+      storeMutationSet.delete(store);
+    }
+    const valueOrPromise = atomRead2(store, atom, getter, options);
+    if ((undefined ? undefined.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
+      console.warn(
+        "Detected store mutation during atom read. This is not supported."
+      );
+    }
+    setAtomStateValueOrPromise(store, atom, valueOrPromise);
+    if (isPromiseLike$1(valueOrPromise)) {
+      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
+      valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
+    }
+    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
+    return atomState;
+  } catch (error) {
+    delete atomState.v;
+    atomState.e = error;
+    ++atomState.n;
+    return atomState;
+  } finally {
+    isSync = false;
+    if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
+      invalidatedAtoms.set(atom, atomState.n);
+      changedAtoms.add(atom);
+      (_b = storeHooks.c) == null ? void 0 : _b.call(storeHooks, atom);
+    }
+  }
+};
+const invalidateDependents = (store, atom) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const invalidatedAtoms = buildingBlocks[2];
+  const ensureAtomState2 = buildingBlocks[11];
+  const stack = [atom];
+  while (stack.length) {
+    const a = stack.pop();
+    const aState = ensureAtomState2(store, a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      const dState = ensureAtomState2(store, d);
+      invalidatedAtoms.set(d, dState.n);
+      stack.push(d);
+    }
+  }
+};
+const writeAtomState = (store, atom, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const atomWrite2 = buildingBlocks[8];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const invalidateDependents2 = buildingBlocks[15];
+  const mountDependencies2 = buildingBlocks[17];
+  let isSync = true;
+  const getter = (a) => returnAtomValue(readAtomState2(store, a));
+  const setter = (a, ...args2) => {
+    var _a;
+    const aState = ensureAtomState2(store, a);
+    try {
+      if (a === atom) {
+        if (!hasInitialValue(a)) {
+          throw new Error("atom not writable");
+        }
+        if ((undefined ? undefined.MODE : void 0) !== "production") {
+          storeMutationSet.add(store);
+        }
+        const prevEpochNumber = aState.n;
+        const v = args2[0];
+        setAtomStateValueOrPromise(store, a, v);
+        mountDependencies2(store, a);
+        if (prevEpochNumber !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents2(store, a);
+          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
+        }
+        return void 0;
+      } else {
+        return writeAtomState(store, a, ...args2);
+      }
+    } finally {
+      if (!isSync) {
+        recomputeInvalidatedAtoms2(store);
+        flushCallbacks2(store);
+      }
+    }
+  };
+  try {
+    return atomWrite2(store, atom, getter, setter, ...args);
+  } finally {
+    isSync = false;
+  }
+};
+const mountDependencies = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const changedAtoms = buildingBlocks[3];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState2 = buildingBlocks[11];
+  const invalidateDependents2 = buildingBlocks[15];
+  const mountAtom2 = buildingBlocks[18];
+  const unmountAtom2 = buildingBlocks[19];
+  const atomState = ensureAtomState2(store, atom);
+  const mounted = mountedMap.get(atom);
+  if (mounted && !isPendingPromise(atomState.v)) {
+    for (const [a, n] of atomState.d) {
+      if (!mounted.d.has(a)) {
+        const aState = ensureAtomState2(store, a);
+        const aMounted = mountAtom2(store, a);
+        aMounted.t.add(atom);
+        mounted.d.add(a);
+        if (n !== aState.n) {
+          changedAtoms.add(a);
+          invalidateDependents2(store, a);
+          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
+        }
+      }
+    }
+    for (const a of mounted.d) {
+      if (!atomState.d.has(a)) {
+        mounted.d.delete(a);
+        const aMounted = unmountAtom2(store, a);
+        aMounted == null ? void 0 : aMounted.t.delete(atom);
+      }
+    }
+  }
+};
+const mountAtom = (store, atom) => {
+  var _a;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const mountCallbacks = buildingBlocks[4];
+  const storeHooks = buildingBlocks[6];
+  const atomOnMount2 = buildingBlocks[10];
+  const ensureAtomState2 = buildingBlocks[11];
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const readAtomState2 = buildingBlocks[14];
+  const writeAtomState2 = buildingBlocks[16];
+  const atomState = ensureAtomState2(store, atom);
+  let mounted = mountedMap.get(atom);
+  if (!mounted) {
+    readAtomState2(store, atom);
+    for (const a of atomState.d.keys()) {
+      const aMounted = mountAtom(store, a);
+      aMounted.t.add(atom);
+    }
+    mounted = {
+      l: /* @__PURE__ */ new Set(),
+      d: new Set(atomState.d.keys()),
+      t: /* @__PURE__ */ new Set()
+    };
+    mountedMap.set(atom, mounted);
+    if (isActuallyWritableAtom(atom)) {
+      const processOnMount = () => {
+        let isSync = true;
+        const setAtom = (...args) => {
+          try {
+            return writeAtomState2(store, atom, ...args);
+          } finally {
+            if (!isSync) {
+              recomputeInvalidatedAtoms2(store);
+              flushCallbacks2(store);
+            }
+          }
+        };
+        try {
+          const onUnmount = atomOnMount2(store, atom, setAtom);
+          if (onUnmount) {
+            mounted.u = () => {
+              isSync = true;
+              try {
+                onUnmount();
+              } finally {
+                isSync = false;
+              }
+            };
+          }
+        } finally {
+          isSync = false;
+        }
+      };
+      mountCallbacks.add(processOnMount);
+    }
+    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
+  }
+  return mounted;
+};
+const unmountAtom = (store, atom) => {
+  var _a, _b;
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const mountedMap = buildingBlocks[1];
+  const unmountCallbacks = buildingBlocks[5];
+  const storeHooks = buildingBlocks[6];
+  const ensureAtomState2 = buildingBlocks[11];
+  const unmountAtom2 = buildingBlocks[19];
+  const atomState = ensureAtomState2(store, atom);
+  let mounted = mountedMap.get(atom);
+  if (!mounted || mounted.l.size) {
+    return mounted;
+  }
+  let isDependent = false;
+  for (const a of mounted.t) {
+    if ((_a = mountedMap.get(a)) == null ? void 0 : _a.d.has(atom)) {
+      isDependent = true;
+      break;
+    }
+  }
+  if (!isDependent) {
+    if (mounted.u) {
+      unmountCallbacks.add(mounted.u);
+    }
+    mounted = void 0;
+    mountedMap.delete(atom);
+    for (const a of atomState.d.keys()) {
+      const aMounted = unmountAtom2(store, a);
+      aMounted == null ? void 0 : aMounted.t.delete(atom);
+    }
+    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
+    return void 0;
+  }
+  return mounted;
+};
+const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState2(store, atom);
+  const hasPrevValue = "v" in atomState;
+  const prevValue = atomState.v;
+  if (isPromiseLike$1(valueOrPromise)) {
+    for (const a of atomState.d.keys()) {
+      addPendingPromiseToDependency(
+        atom,
+        valueOrPromise,
+        ensureAtomState2(store, a)
+      );
+    }
+  }
+  atomState.v = valueOrPromise;
+  delete atomState.e;
+  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+    ++atomState.n;
+    if (isPromiseLike$1(prevValue)) {
+      abortPromise(prevValue);
+    }
+  }
+};
+const storeGet = (store, atom) => {
+  const readAtomState2 = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState2(store, atom));
+};
+const storeSet = (store, atom, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks2 = buildingBlocks[12];
+  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const writeAtomState2 = buildingBlocks[16];
+  try {
+    return writeAtomState2(store, atom, ...args);
+  } finally {
+    recomputeInvalidatedAtoms2(store);
+    flushCallbacks2(store);
+  }
+};
+const storeSub = (store, atom, listener) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  const flushCallbacks2 = buildingBlocks[12];
+  const mountAtom2 = buildingBlocks[18];
+  const unmountAtom2 = buildingBlocks[19];
+  const mounted = mountAtom2(store, atom);
+  const listeners = mounted.l;
+  listeners.add(listener);
+  flushCallbacks2(store);
+  return () => {
+    listeners.delete(listener);
+    unmountAtom2(store, atom);
+    flushCallbacks2(store);
+  };
+};
+const buildingBlockMap = /* @__PURE__ */ new WeakMap();
+const getInternalBuildingBlocks = (store) => {
+  const buildingBlocks = buildingBlockMap.get(store);
+  if ((undefined ? undefined.MODE : void 0) !== "production" && !buildingBlocks) {
+    throw new Error(
+      "Store must be created by buildStore to read its building blocks"
+    );
+  }
+  return buildingBlocks;
+};
+function buildStore(...buildArgs) {
+  const store = {
+    get(atom) {
+      const storeGet2 = getInternalBuildingBlocks(store)[21];
+      return storeGet2(store, atom);
+    },
+    set(atom, ...args) {
+      const storeSet2 = getInternalBuildingBlocks(store)[22];
+      return storeSet2(store, atom, ...args);
+    },
+    sub(atom, listener) {
+      const storeSub2 = getInternalBuildingBlocks(store)[23];
+      return storeSub2(store, atom, listener);
+    }
+  };
+  const buildingBlocks = [
+    // store state
+    /* @__PURE__ */ new WeakMap(),
+    // atomStateMap
+    /* @__PURE__ */ new WeakMap(),
+    // mountedMap
+    /* @__PURE__ */ new WeakMap(),
+    // invalidatedAtoms
+    /* @__PURE__ */ new Set(),
+    // changedAtoms
+    /* @__PURE__ */ new Set(),
+    // mountCallbacks
+    /* @__PURE__ */ new Set(),
+    // unmountCallbacks
+    {},
+    // storeHooks
+    // atom interceptors
+    atomRead,
+    atomWrite,
+    atomOnInit,
+    atomOnMount,
+    // building-block functions
+    ensureAtomState,
+    flushCallbacks,
+    recomputeInvalidatedAtoms,
+    readAtomState,
+    invalidateDependents,
+    writeAtomState,
+    mountDependencies,
+    mountAtom,
+    unmountAtom,
+    setAtomStateValueOrPromise,
+    storeGet,
+    storeSet,
+    storeSub,
+    void 0
+  ].map((fn, i) => buildArgs[i] || fn);
+  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
+  return store;
+}let keyCount = 0;
+function atom(read, write) {
+  const key = `atom${++keyCount}`;
+  const config = {
+    toString() {
+      return (undefined ? undefined.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
+    }
+  };
+  if (typeof read === "function") {
+    config.read = read;
+  } else {
+    config.init = read;
+    config.read = defaultRead;
+    config.write = defaultWrite;
+  }
+  if (write) {
+    config.write = write;
+  }
+  return config;
+}
+function defaultRead(get) {
+  return get(this);
+}
+function defaultWrite(get, set, arg) {
+  return set(
+    this,
+    typeof arg === "function" ? arg(get(this)) : arg
+  );
+}
+function createStore() {
+  return buildStore();
+}
+let defaultStore;
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createStore();
+    if ((undefined ? undefined.MODE : void 0) !== "production") {
+      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
+      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
+        console.warn(
+          "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+        );
+      }
+    }
+  }
+  return defaultStore;
+}const StoreContext = React.createContext(
+  void 0
+);
+function useStore(options) {
+  const store = React.useContext(StoreContext);
+  return store || getDefaultStore();
+}
+
+const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const attachPromiseStatus = (promise) => {
+  if (!promise.status) {
+    promise.status = "pending";
+    promise.then(
+      (v) => {
+        promise.status = "fulfilled";
+        promise.value = v;
+      },
+      (e) => {
+        promise.status = "rejected";
+        promise.reason = e;
+      }
+    );
+  }
+};
+const use = React.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
+    throw promise;
+  }
+});
+const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+const createContinuablePromise = (promise, getValue) => {
+  let continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise((resolve, reject) => {
+      let curr = promise;
+      const onFulfilled = (me) => (v) => {
+        if (curr === me) {
+          resolve(v);
+        }
+      };
+      const onRejected = (me) => (e) => {
+        if (curr === me) {
+          reject(e);
+        }
+      };
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            registerAbortHandler(nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      registerAbortHandler(promise, onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
+function useAtomValue(atom, options) {
+  const { delay, unstable_promiseStatus: promiseStatus = !React.use } = {};
+  const store = useStore();
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = React.useReducer(
+    (prev) => {
+      const nextValue = store.get(atom);
+      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+        return prev;
+      }
+      return [nextValue, store, atom];
+    },
+    void 0,
+    () => [store.get(atom), store, atom]
+  );
+  let value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  React.useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      if (promiseStatus) {
+        try {
+          const value2 = store.get(atom);
+          if (isPromiseLike(value2)) {
+            attachPromiseStatus(
+              createContinuablePromise(value2, () => store.get(atom))
+            );
+          }
+        } catch (e) {
+        }
+      }
+      if (typeof delay === "number") {
+        setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    rerender();
+    return unsub;
+  }, [store, atom, delay, promiseStatus]);
+  React.useDebugValue(value);
+  if (isPromiseLike(value)) {
+    const promise = createContinuablePromise(value, () => store.get(atom));
+    if (promiseStatus) {
+      attachPromiseStatus(promise);
+    }
+    return use(promise);
+  }
+  return value;
+}
+
+function useSetAtom(atom, options) {
+  const store = useStore();
+  const setAtom = React.useCallback(
+    (...args) => {
+      if ((undefined ? undefined.MODE : void 0) !== "production" && !("write" in atom)) {
+        throw new Error("not writable atom");
+      }
+      return store.set(atom, ...args);
+    },
+    [store, atom]
+  );
+  return setAtom;
+}
+
+function useAtom(atom, options) {
+  return [
+    useAtomValue(atom),
+    // We do wrong type assertion here, which results in throwing an error.
+    useSetAtom(atom)
+  ];
+}/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Optimized shallow equality check for objects and functions
+ * @param objA - First object to compare
+ * @param objB - Second object to compare
+ * @returns True if objects are shallow equal
+ */
+function shallowEqual(objA, objB) {
+  if (objA === objB) return true;
+  if (!objA || !objB) return false;
+  if (typeof objA !== 'object' || typeof objB !== 'object') {
+    return objA === objB;
+  }
+  if (typeof objA === 'function' && typeof objB === 'function') {
+    return objA.name === objB.name && objA.toString() === objB.toString();
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    const valA = objA[key];
+    const valB = objB[key];
+    if (typeof valA === 'function' && typeof valB === 'function') {
+      if (valA.name !== valB.name || valA.toString() !== valB.toString()) {
+        return false;
+      }
+      continue;
+    }
+    if (valA !== valB) return false;
+  }
+  return true;
+}
+/**
+ * Checks if a value is stable for React dependency arrays
+ * @param value - Value to check for stability
+ * @returns True if value is considered stable
+ */
+function isStableValue(value) {
+  if (value === null || value === undefined) return true;
+  if (typeof value !== 'object' && typeof value !== 'function') return true;
+  if (typeof value === 'function') return value.toString().length < 1000;
+  return false;
+}
+/**
+ * Creates an optimized dependency array by filtering unstable values
+ * @param deps - Array of dependencies to optimize
+ * @returns Filtered array of stable dependencies
+ */
+function optimizeDeps(deps) {
+  return deps.filter(dep => isStableValue(dep) || typeof dep === 'object');
+}
+/**
+ * Custom prop comparator for React.memo() to prevent unnecessary re-renders
+ * Compares props shallowly and ignores function references if they have the same name
+ * @param prevProps - Previous component props
+ * @param nextProps - Next component props
+ * @returns True if props are equal (component should NOT re-render)
+ */
+function memoPropsComparator(prevProps, nextProps) {
+  return shallowEqual(prevProps, nextProps);
+}
+/**
+ * Deep equality check for complex objects
+ * Use sparingly - prefer shallow equality for performance
+ * Uses fast-deep-equal library for optimized deep comparison with circular reference protection
+ * @param objA - First object
+ * @param objB - Second object
+ * @returns True if objects are deeply equal
+ */
+function deepEqual(objA, objB) {
+  return equal(objA, objB);
+}
+/**
+ * Memoization cache for expensive computations
+ * Simple LRU cache with configurable size
+ */
+class MemoizationCache {
+  constructor(maxSize = 100) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      // Move to end (most recently used)
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    // Delete oldest entry if cache is full
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+/**
+ * Creates a memoized function with custom cache key generator
+ * @param fn - Function to memoize
+ * @param cacheKeyFn - Optional function to generate cache key from arguments
+ * @returns Memoized function
+ */
+function memoize(fn, cacheKeyFn) {
+  const cache = new MemoizationCache();
+  return (...args) => {
+    const cacheKey = cacheKeyFn ? cacheKeyFn(...args) : JSON.stringify(args);
+    if (cache.has(cacheKey)) {
+      return cache.get(cacheKey);
+    }
+    const result = fn(...args);
+    cache.set(cacheKey, result);
+    return result;
+  };
+}function atomFamily(initializeAtom, areEqual) {
+    let shouldRemove = null;
+    const atoms = new Map();
+    const listeners = new Set();
+    function createAtom(param) {
+        let item;
+        {
+            item = atoms.get(param);
+        }
+        if (item !== undefined) {
+            if (shouldRemove?.(item[1], param)) {
+                createAtom.remove(param);
+            }
+            else {
+                return item[0];
+            }
+        }
+        const newAtom = initializeAtom(param);
+        atoms.set(param, [newAtom, Date.now()]);
+        notifyListeners('CREATE', param, newAtom);
+        return newAtom;
+    }
+    function notifyListeners(type, param, atom) {
+        for (const listener of listeners) {
+            listener({ type, param, atom });
+        }
+    }
+    createAtom.unstable_listen = (callback) => {
+        listeners.add(callback);
+        return () => {
+            listeners.delete(callback);
+        };
+    };
+    createAtom.getParams = () => atoms.keys();
+    createAtom.remove = (param) => {
+        {
+            if (!atoms.has(param))
+                return;
+            const [atom] = atoms.get(param);
+            atoms.delete(param);
+            notifyListeners('REMOVE', param, atom);
+        }
+    };
+    createAtom.setShouldRemove = (fn) => {
+        shouldRemove = fn;
+        if (!shouldRemove)
+            return;
+        for (const [key, [atom, createdAt]] of atoms) {
+            if (shouldRemove(createdAt, key)) {
+                atoms.delete(key);
+                notifyListeners('REMOVE', key, atom);
+            }
+        }
+    };
+    return createAtom;
+}const pageVariablesAtomFamily = atomFamily(_pageId => atom({}));
+/**
+ * Global atom storing all page variables.
+ * Key format: "scopeId:pageId"
+ */
+const pageVariablesAtom = atom({});
+/**
+ * Helper to generate composite keys for page variables.
+ */
+const getPageVariablesCompositeKey = (scopeId, key) => `${scopeId}:${key}`;
+/**
+ * Creates a derived atom for accessing page variables of a specific scope.
+ */
+const createScopePageVariablesAtom = scopeId => atom(get => {
+  const allPageVariables = get(pageVariablesAtom);
+  const prefix = `${scopeId}:`;
+  const scopePageVariables = {};
+  for (const [key, value] of Object.entries(allPageVariables)) {
+    if (key.startsWith(prefix)) {
+      scopePageVariables[key.slice(prefix.length)] = value;
+    }
+  }
+  return scopePageVariables;
+}, (get, set, update) => {
+  const allPageVariables = get(pageVariablesAtom);
+  const prefix = `${scopeId}:`;
+  const newPageVariables = Object.assign({}, allPageVariables);
+  // Remove old scope entries
+  for (const key of Object.keys(newPageVariables)) {
+    if (key.startsWith(prefix)) {
+      delete newPageVariables[key];
+    }
+  }
+  // Add new scope entries
+  for (const [key, value] of Object.entries(update)) {
+    newPageVariables[`${prefix}${key}`] = value;
+  }
+  set(pageVariablesAtom, newPageVariables);
+});const getValueAtPath = (obj, path) => {
+  if (!path) return undefined;
+  const normalized = path.replace(/\[(\d+)\]/g, '.$1');
+  const parts = normalized.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current == null) return undefined;
+    if (typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+};
+const usePageValues = ({
+  pageId,
+  initialValues
+}) => {
+  const {
+    get: getApiValues
+  } = reactQueries.useApiValues({
+    scopeId: pageId
+  });
+  const {
+    get: getFormValues,
+    set: setFormValues
+  } = reactForm.useFormValues({
+    formId: pageId
+  });
+  const subscriptions = React.useRef(new Map());
+  const [trigger, setTrigger] = React.useState(0);
+  const [pageVariables, setPageVariables] = useAtom(pageVariablesAtomFamily(pageId));
+  const initialized = React.useRef(false);
+  React.useEffect(() => {
+    if (!initialized.current && initialValues) {
+      setPageVariables(initialValues);
+      initialized.current = true;
+    }
+  }, [initialValues, setPageVariables]);
+  const dataRef = React.useRef({
+    state: pageVariables
+  });
+  // Sync dataRef with latest values
+  React.useEffect(() => {
+    let internalTrigger = false;
+    subscriptions.current.forEach((_, key) => {
+      const [type, keyPath] = key.split(':');
+      if (type === 'state') {
+        const newValue = getValueAtPath(pageVariables, keyPath);
+        const oldValue = getValueAtPath(dataRef.current.state, keyPath);
+        internalTrigger = internalTrigger || !equal(newValue, oldValue);
+      }
+    });
+    dataRef.current = {
+      state: pageVariables
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (internalTrigger) {
+      setTrigger(v => v + 1);
+    }
+  }, [pageVariables]);
+  // get che legge dallo store e registra le dipendenze
+  const get = React.useCallback((type, key, defaultValue) => {
+    var _a;
+    const keyMap = `${type}:${key}`;
+    switch (type) {
+      case 'mutation':
+        {
+          const value = getApiValues(type, key, defaultValue);
+          subscriptions.current.set(keyMap, value);
+          break;
+        }
+      case 'query':
+        {
+          const value = getApiValues(type, key, defaultValue);
+          subscriptions.current.set(keyMap, value);
+          break;
+        }
+      case 'form':
+        {
+          const value = getFormValues(key, defaultValue);
+          subscriptions.current.set(keyMap, value);
+          break;
+        }
+      case 'state':
+        {
+          const value = (_a = getValueAtPath(dataRef.current['state'], String(key))) !== null && _a !== void 0 ? _a : defaultValue;
+          subscriptions.current.set(keyMap, value);
+          break;
+        }
+    }
+    return subscriptions.current.get(keyMap);
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [pageId, trigger, getApiValues, getFormValues]);
+  // set stabile
+  const set = React.useCallback(type => {
+    if (type === 'form') {
+      return setFormValues;
+    }
+    return (key, value) => {
+      setPageVariables(prev => Object.assign(Object.assign({}, prev), {
+        [key]: value
+      }));
+    };
+  }, [setPageVariables, setFormValues]);
+  return {
+    get,
+    set
+  };
+};const getStableKey = (content, index) => {
+  var _a;
+  return (_a = content.key) !== null && _a !== void 0 ? _a : `content-${index}`;
+};
+const PageContentItemInner = ({
+  item,
+  pageId,
+  ns
+}) => {
+  var _a;
+  const {
+    get,
+    set
+  } = usePageValues({
+    pageId
+  });
+  const isHidden = React.useMemo(() => {
+    if (typeof item.hidden === 'function') {
+      return item.hidden({
+        get,
+        set
+      });
+    }
+    return !!item.hidden;
+  }, [get, item, set]);
+  if (isHidden) return null;
+  return jsxRuntime.jsx(RenderComponents, {
+    content: item,
+    ns: ns,
+    pageId: pageId
+  }, (_a = item.key) !== null && _a !== void 0 ? _a : '');
+};
+const PageContentItem = React.memo(PageContentItemInner);
+const useGenerateContentRender = ({
+  pageId,
+  ns = '',
+  contents = [],
+  formData
+}) => {
+  const {
+    get,
+    set
+  } = usePageValues({
+    pageId
+  });
+  const contentsWithQueriesDeps = React.useMemo(() => {
+    if (typeof contents === 'function') {
+      return contents({
+        get,
+        set
+      });
+    }
+    return Array.isArray(contents) ? contents : [];
+  }, [contents, get, set]);
+  // Memoize form elements separately - only recalculate when formData.elements changes
+  const formElementsWithKey = React.useMemo(() => {
+    if (!Array.isArray(formData.elements)) return [];
+    return formData.elements.map((el, idx) => Object.assign(Object.assign({}, el), {
+      key: `form-element-${el.index || idx}`
+    }));
+  }, [formData.elements]);
+  // Memoize dynamic elements - only recalculate when contents change
+  const dynamicElements = React.useMemo(() => contentsWithQueriesDeps.map((content, index) => {
+    var _a;
+    const stableKey = getStableKey(content, index);
+    return {
+      element: jsxRuntime.jsx(PageContentItem, {
+        item: content,
+        ns: ns,
+        pageId: pageId
+      }, stableKey),
+      index: (_a = content.index) !== null && _a !== void 0 ? _a : index,
+      renderInFooter: !!content.renderInFooter,
+      renderInHeader: !!content.renderInHeader,
+      key: stableKey
+    };
+  }), [contentsWithQueriesDeps, ns, pageId]);
+  // Merge and sort - only when either array changes
+  const memorizedContents = React.useMemo(() => [...dynamicElements, ...formElementsWithKey].sort((a, b) => a.index - b.index || String(a.key).localeCompare(String(b.key))), [dynamicElements, formElementsWithKey]);
+  return {
+    components: memorizedContents,
+    allContents: [...contentsWithQueriesDeps, ...formData.formContents]
+  };
+};const useGenerateContent = t0 => {
+  const $ = compilerRuntime.c(18);
+  const {
+    pageId,
+    ns: t1,
+    contents: t2,
+    pageConfig
+  } = t0;
+  const ns = t1 === undefined ? "" : t1;
+  let t3;
+  if ($[0] !== t2) {
+    t3 = t2 === undefined ? [] : t2;
+    $[0] = t2;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const contents = t3;
+  const {
+    formData
+  } = pageConfig;
+  let t4;
+  if ($[2] !== contents || $[3] !== formData || $[4] !== ns || $[5] !== pageId) {
+    t4 = {
+      formData,
+      pageId,
+      contents,
+      ns
+    };
+    $[2] = contents;
+    $[3] = formData;
+    $[4] = ns;
+    $[5] = pageId;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  const {
+    allContents,
+    components
+  } = useGenerateContentRender(t4);
+  let t5;
+  if ($[7] !== components) {
+    t5 = components.filter(_temp$1).map(_temp2$1);
+    $[7] = components;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  const body = t5;
+  let t6;
+  if ($[9] !== components) {
+    t6 = components.filter(_temp3).map(_temp4);
+    $[9] = components;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  const header = t6;
+  let t7;
+  if ($[11] !== components) {
+    t7 = components.filter(_temp5).map(_temp6);
+    $[11] = components;
+    $[12] = t7;
+  } else {
+    t7 = $[12];
+  }
+  const footer = t7;
+  let t8;
+  if ($[13] !== allContents || $[14] !== body || $[15] !== footer || $[16] !== header) {
+    t8 = {
+      header,
+      body,
+      footer,
+      allContents
+    };
+    $[13] = allContents;
+    $[14] = body;
+    $[15] = footer;
+    $[16] = header;
+    $[17] = t8;
+  } else {
+    t8 = $[17];
+  }
+  return t8;
+};
+function _temp$1(el) {
+  return !el.renderInFooter && !el.renderInHeader;
+}
+function _temp2$1(item) {
+  return item.element;
+}
+function _temp3(el_0) {
+  return el_0.renderInHeader;
+}
+function _temp4(item_0) {
+  return item_0.element;
+}
+function _temp5(el_1) {
+  return el_1.renderInFooter;
+}
+function _temp6(item_1) {
+  return item_1.element;
+}/**
+ * Metadata Store, DOM Application, and Server Collection
+ *
+ * Architecture:
+ * - `createMetadataStore()` → request-scoped store (SSR-safe)
+ * - `applyMetadataToDom(resolved)` → client-side DOM manipulation
+ * - `collectMetadataToHtml(resolved)` → server-side HTML string collection
+ * - `setMetadata / getMetadata / resetMetadata` → backward-compatible global API
+ *
+ * @module config/metadata
+ */
+// ─── Platform detection ──────────────────────────────────────
+const isWeb = typeof document !== 'undefined';
+// ─── Request-scoped Metadata Store ───────────────────────────
+/**
+ * Create a new request-scoped metadata store.
+ * In SSR, each incoming request should create its own store
+ * to avoid cross-request data leaks.
+ * On the client, a single global store is used (see below).
+ */
+function createMetadataStore() {
+  let metadata = {};
+  return {
+    getMetadata: () => Object.assign({}, metadata),
+    setMetadata: meta => {
+      metadata = Object.assign(Object.assign({}, metadata), meta);
+    },
+    reset: () => {
+      metadata = {};
+    }
+  };
+}
+/** Global store for client-side usage (singleton) */
+const globalStore = createMetadataStore();
+// ─── DOM helpers ─────────────────────────────────────────────
+function updateOrCreateMeta(selector, content, attributes = {}) {
+  let element = document.querySelector(selector);
+  if (!element) {
+    element = document.createElement('meta');
+    Object.entries(attributes).forEach(([key, value]) => {
+      element === null || element === void 0 ? void 0 : element.setAttribute(key, value);
+    });
+    document.head.appendChild(element);
+  }
+  element.setAttribute('content', content);
+}
+function updateOrCreateLink(selector, attributes) {
+  let element = document.querySelector(selector);
+  if (!element) {
+    element = document.createElement('link');
+    document.head.appendChild(element);
+  }
+  Object.entries(attributes).forEach(([key, value]) => {
+    element.setAttribute(key, value);
+  });
+}
+// ─── applyMetadataToDom ─────────────────────────────────────
+/**
+ * Apply resolved metadata to the document `<head>`.
+ * Client-only: this function does nothing if `document` is not available.
+ * Covers: title, description, canonical, lang, keywords, author, viewport,
+ *         themeColor, Open Graph (advanced), Twitter Card, alternates/hreflang,
+ *         icons, manifest, structured data JSON-LD, AI hints, robots, customMeta.
+ */
+function applyMetadataToDom(resolved) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!isWeb) return;
+  // ── Title ───────────────────────────────────────────────────
+  if (resolved.title) {
+    document.title = resolved.title;
+  }
+  // ── Standard meta tags ──────────────────────────────────────
+  if (resolved.description) {
+    updateOrCreateMeta('meta[name="description"]', resolved.description, {
+      name: 'description'
+    });
+  }
+  if ((_a = resolved.keywords) === null || _a === void 0 ? void 0 : _a.length) {
+    updateOrCreateMeta('meta[name="keywords"]', resolved.keywords.join(', '), {
+      name: 'keywords'
+    });
+  }
+  if (resolved.author) {
+    updateOrCreateMeta('meta[name="author"]', resolved.author, {
+      name: 'author'
+    });
+  }
+  if (resolved.viewport) {
+    updateOrCreateMeta('meta[name="viewport"]', resolved.viewport, {
+      name: 'viewport'
+    });
+  }
+  if (resolved.themeColor) {
+    updateOrCreateMeta('meta[name="theme-color"]', resolved.themeColor, {
+      name: 'theme-color'
+    });
+  }
+  // ── Canonical ───────────────────────────────────────────────
+  if (resolved.canonical) {
+    updateOrCreateLink('link[rel="canonical"]', {
+      rel: 'canonical',
+      href: resolved.canonical
+    });
+  }
+  // ── Language ────────────────────────────────────────────────
+  if (resolved.lang) {
+    document.documentElement.lang = resolved.lang;
+  }
+  // ── Open Graph ──────────────────────────────────────────────
+  if (resolved.openGraph) {
+    const og = resolved.openGraph;
+    if (og.title) {
+      updateOrCreateMeta('meta[property="og:title"]', og.title, {
+        property: 'og:title'
+      });
+    }
+    if (og.description) {
+      updateOrCreateMeta('meta[property="og:description"]', og.description, {
+        property: 'og:description'
+      });
+    }
+    if (og.type) {
+      updateOrCreateMeta('meta[property="og:type"]', og.type, {
+        property: 'og:type'
+      });
+    }
+    if (og.url) {
+      updateOrCreateMeta('meta[property="og:url"]', og.url, {
+        property: 'og:url'
+      });
+    }
+    if (og.siteName) {
+      updateOrCreateMeta('meta[property="og:site_name"]', og.siteName, {
+        property: 'og:site_name'
+      });
+    }
+    if (og.locale) {
+      updateOrCreateMeta('meta[property="og:locale"]', og.locale, {
+        property: 'og:locale'
+      });
+    }
+    // OG images (advanced: multiple + alt/width/height)
+    if ((_b = og.images) === null || _b === void 0 ? void 0 : _b.length) {
+      applyOgImages(og.images);
+    } else if (og.image) {
+      const img = typeof og.image === 'string' ? {
+        url: og.image
+      } : og.image;
+      applyOgImages([img]);
+    }
+    // OG article metadata
+    if (og.article) {
+      const art = og.article;
+      if (art.publishedTime) {
+        updateOrCreateMeta('meta[property="article:published_time"]', art.publishedTime, {
+          property: 'article:published_time'
+        });
+      }
+      if (art.modifiedTime) {
+        updateOrCreateMeta('meta[property="article:modified_time"]', art.modifiedTime, {
+          property: 'article:modified_time'
+        });
+      }
+      if (art.expirationTime) {
+        updateOrCreateMeta('meta[property="article:expiration_time"]', art.expirationTime, {
+          property: 'article:expiration_time'
+        });
+      }
+      if (art.section) {
+        updateOrCreateMeta('meta[property="article:section"]', art.section, {
+          property: 'article:section'
+        });
+      }
+      const authors = Array.isArray(art.author) ? art.author : art.author ? [art.author] : [];
+      authors.forEach((author, i) => {
+        updateOrCreateMeta(`meta[property="article:author"][data-index="${i}"]`, author, {
+          property: 'article:author',
+          'data-index': String(i)
+        });
+      });
+      (_c = art.tags) === null || _c === void 0 ? void 0 : _c.forEach((tag, i) => {
+        updateOrCreateMeta(`meta[property="article:tag"][data-index="${i}"]`, tag, {
+          property: 'article:tag',
+          'data-index': String(i)
+        });
+      });
+    }
+  }
+  // ── Twitter Card ────────────────────────────────────────────
+  if (resolved.twitter) {
+    const tw = resolved.twitter;
+    if (tw.card) {
+      updateOrCreateMeta('meta[name="twitter:card"]', tw.card, {
+        name: 'twitter:card'
+      });
+    }
+    if (tw.site) {
+      updateOrCreateMeta('meta[name="twitter:site"]', tw.site, {
+        name: 'twitter:site'
+      });
+    }
+    if (tw.creator) {
+      updateOrCreateMeta('meta[name="twitter:creator"]', tw.creator, {
+        name: 'twitter:creator'
+      });
+    }
+    if (tw.title) {
+      updateOrCreateMeta('meta[name="twitter:title"]', tw.title, {
+        name: 'twitter:title'
+      });
+    }
+    if (tw.description) {
+      updateOrCreateMeta('meta[name="twitter:description"]', tw.description, {
+        name: 'twitter:description'
+      });
+    }
+    if (tw.image) {
+      updateOrCreateMeta('meta[name="twitter:image"]', tw.image, {
+        name: 'twitter:image'
+      });
+    }
+    if (tw.imageAlt) {
+      updateOrCreateMeta('meta[name="twitter:image:alt"]', tw.imageAlt, {
+        name: 'twitter:image:alt'
+      });
+    }
+  }
+  // ── Alternates / hreflang ───────────────────────────────────
+  if (resolved.alternates) {
+    const alt = resolved.alternates;
+    if (alt.canonical) {
+      updateOrCreateLink('link[rel="canonical"]', {
+        rel: 'canonical',
+        href: alt.canonical
+      });
+    }
+    if (alt.languages) {
+      // Remove old hreflang links first
+      document.querySelectorAll('link[rel="alternate"][hreflang]').forEach(el => el.remove());
+      Object.entries(alt.languages).forEach(([locale, url]) => {
+        const link = document.createElement('link');
+        link.rel = 'alternate';
+        link.hreflang = locale;
+        link.href = url;
+        document.head.appendChild(link);
+      });
+    }
+    if (alt.media) {
+      Object.entries(alt.media).forEach(([mediaQuery, url]) => {
+        updateOrCreateLink(`link[rel="alternate"][media="${mediaQuery}"]`, {
+          rel: 'alternate',
+          media: mediaQuery,
+          href: url
+        });
+      });
+    }
+    if (alt.types) {
+      Object.entries(alt.types).forEach(([mimeType, items]) => {
+        items.forEach((item, i) => {
+          const selector = `link[rel="alternate"][type="${mimeType}"][data-index="${i}"]`;
+          const attrs = {
+            rel: 'alternate',
+            type: mimeType,
+            href: item.url,
+            'data-index': String(i)
+          };
+          if (item.title) attrs.title = item.title;
+          updateOrCreateLink(selector, attrs);
+        });
+      });
+    }
+  }
+  // ── Icons ───────────────────────────────────────────────────
+  if (resolved.icons) {
+    applyIcons(resolved.icons.icon, 'icon');
+    applyIcons(resolved.icons.apple, 'apple-touch-icon');
+    if (resolved.icons.shortcut) {
+      updateOrCreateLink('link[rel="shortcut icon"]', {
+        rel: 'shortcut icon',
+        href: resolved.icons.shortcut
+      });
+    }
+  }
+  // ── Manifest ────────────────────────────────────────────────
+  if (resolved.manifest) {
+    updateOrCreateLink('link[rel="manifest"]', {
+      rel: 'manifest',
+      href: resolved.manifest
+    });
+  }
+  // ── Structured data JSON-LD ─────────────────────────────────
+  if (resolved.structuredData) {
+    const schemaScriptId = 'react-pages-schema-org';
+    let scriptElement = document.querySelector(`script[id="${schemaScriptId}"]`);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!scriptElement) {
+      scriptElement = document.createElement('script');
+      scriptElement.type = 'application/ld+json';
+      scriptElement.id = schemaScriptId;
+      document.head.appendChild(scriptElement);
+    }
+    scriptElement.textContent = JSON.stringify(Object.assign({
+      '@context': 'https://schema.org',
+      '@type': resolved.structuredData.type
+    }, resolved.structuredData.schema));
+  }
+  // ── AI crawler hints ────────────────────────────────────────
+  if (resolved.aiHints) {
+    const hints = resolved.aiHints;
+    if (hints.contentClassification) {
+      updateOrCreateMeta('meta[name="ai-content-classification"]', hints.contentClassification, {
+        name: 'ai-content-classification'
+      });
+    }
+    if ((_d = hints.modelHints) === null || _d === void 0 ? void 0 : _d.length) {
+      updateOrCreateMeta('meta[name="ai-model-hints"]', hints.modelHints.join(', '), {
+        name: 'ai-model-hints'
+      });
+    }
+    if (hints.contextualInfo) {
+      updateOrCreateMeta('meta[name="ai-context"]', hints.contextualInfo, {
+        name: 'ai-context'
+      });
+    }
+    if (hints.excludeFromIndexing) {
+      updateOrCreateMeta('meta[name="ai-exclude-from-indexing"]', 'true', {
+        name: 'ai-exclude-from-indexing'
+      });
+    }
+  }
+  // ── Robots ──────────────────────────────────────────────────
+  if (resolved.robots || resolved.disableIndexing) {
+    const robots = (_e = resolved.robots) !== null && _e !== void 0 ? _e : {};
+    const noindex = resolved.disableIndexing || robots.noindex;
+    const nofollow = resolved.disableIndexing || robots.nofollow;
+    const robotsValue = [noindex ? 'noindex' : 'index', nofollow ? 'nofollow' : 'follow', robots.noarchive && 'noarchive', robots.nosnippet && 'nosnippet', robots.maxImagePreview && `max-image-preview:${robots.maxImagePreview}`, robots.maxSnippet != null && `max-snippet:${robots.maxSnippet}`].filter(Boolean).join(', ');
+    updateOrCreateMeta('meta[name="robots"]', robotsValue, {
+      name: 'robots'
+    });
+  }
+  // ── Custom meta tags ────────────────────────────────────────
+  if ((_f = resolved.customMeta) === null || _f === void 0 ? void 0 : _f.length) {
+    resolved.customMeta.forEach(tag => {
+      const selector = tag.id ? `meta[id="${tag.id}"]` : tag.name ? `meta[name="${tag.name}"]` : tag.property ? `meta[property="${tag.property}"]` : `meta[http-equiv="${tag.httpEquiv}"]`;
+      const attributes = tag.name ? {
+        name: tag.name
+      } : tag.property ? {
+        property: tag.property
+      } : tag.httpEquiv ? {
+        'http-equiv': tag.httpEquiv
+      } : {};
+      if (tag.id) attributes.id = tag.id;
+      updateOrCreateMeta(selector, tag.content, attributes);
+    });
+  }
+}
+/** Apply OG images to the DOM (supports multiple images with alt/width/height) */
+function applyOgImages(images) {
+  // Remove existing OG image tags to avoid stale data
+  document.querySelectorAll('meta[property="og:image"], meta[property="og:image:alt"], meta[property="og:image:width"], meta[property="og:image:height"], meta[property="og:image:type"]').forEach(el => el.remove());
+  images.forEach(img => {
+    const ogImg = document.createElement('meta');
+    ogImg.setAttribute('property', 'og:image');
+    ogImg.setAttribute('content', img.url);
+    document.head.appendChild(ogImg);
+    if (img.alt) {
+      const altMeta = document.createElement('meta');
+      altMeta.setAttribute('property', 'og:image:alt');
+      altMeta.setAttribute('content', img.alt);
+      document.head.appendChild(altMeta);
+    }
+    if (img.width) {
+      const wMeta = document.createElement('meta');
+      wMeta.setAttribute('property', 'og:image:width');
+      wMeta.setAttribute('content', String(img.width));
+      document.head.appendChild(wMeta);
+    }
+    if (img.height) {
+      const hMeta = document.createElement('meta');
+      hMeta.setAttribute('property', 'og:image:height');
+      hMeta.setAttribute('content', String(img.height));
+      document.head.appendChild(hMeta);
+    }
+    if (img.type) {
+      const tMeta = document.createElement('meta');
+      tMeta.setAttribute('property', 'og:image:type');
+      tMeta.setAttribute('content', img.type);
+      document.head.appendChild(tMeta);
+    }
+  });
+}
+/** Apply icon link tags to the DOM */
+function applyIcons(icons, rel) {
+  if (!icons) return;
+  const iconList = typeof icons === 'string' ? [{
+    url: icons
+  }] : Array.isArray(icons) ? icons : [icons];
+  // Remove old icons of this rel
+  document.querySelectorAll(`link[rel="${rel}"]`).forEach(el => el.remove());
+  iconList.forEach(icon => {
+    const link = document.createElement('link');
+    link.rel = rel;
+    link.href = icon.url;
+    if (icon.type) link.type = icon.type;
+    if (icon.sizes) link.setAttribute('sizes', icon.sizes);
+    if (icon.color) link.setAttribute('color', icon.color);
+    document.head.appendChild(link);
+  });
+}
+// ─── collectMetadataToHtml (SSR) ─────────────────────────────
+/**
+ * Collect resolved metadata as an HTML string for SSR injection into `<head>`.
+ * Pure function — no DOM, no side effects.
+ */
+function collectMetadataToHtml(resolved) {
+  var _a, _b, _c, _d, _e, _f;
+  const tags = [];
+  if (resolved.title) {
+    tags.push(`<title>${escapeHtml(resolved.title)}</title>`);
+  }
+  if (resolved.description) {
+    tags.push(`<meta name="description" content="${escapeAttr(resolved.description)}" />`);
+  }
+  if (resolved.canonical) {
+    tags.push(`<link rel="canonical" href="${escapeAttr(resolved.canonical)}" />`);
+  }
+  if ((_a = resolved.keywords) === null || _a === void 0 ? void 0 : _a.length) {
+    tags.push(`<meta name="keywords" content="${escapeAttr(resolved.keywords.join(', '))}" />`);
+  }
+  if (resolved.author) {
+    tags.push(`<meta name="author" content="${escapeAttr(resolved.author)}" />`);
+  }
+  if (resolved.viewport) {
+    tags.push(`<meta name="viewport" content="${escapeAttr(resolved.viewport)}" />`);
+  }
+  if (resolved.themeColor) {
+    tags.push(`<meta name="theme-color" content="${escapeAttr(resolved.themeColor)}" />`);
+  }
+  // Open Graph
+  if (resolved.openGraph) {
+    const og = resolved.openGraph;
+    if (og.type) tags.push(ogMeta('og:type', og.type));
+    if (og.title) tags.push(ogMeta('og:title', og.title));
+    if (og.description) tags.push(ogMeta('og:description', og.description));
+    if (og.url) tags.push(ogMeta('og:url', og.url));
+    if (og.siteName) tags.push(ogMeta('og:site_name', og.siteName));
+    if (og.locale) tags.push(ogMeta('og:locale', og.locale));
+    const images = (_b = og.images) !== null && _b !== void 0 ? _b : og.image ? [typeof og.image === 'string' ? {
+      url: og.image
+    } : og.image] : [];
+    images.forEach(img => {
+      tags.push(ogMeta('og:image', img.url));
+      if (img.alt) tags.push(ogMeta('og:image:alt', img.alt));
+      if (img.width) tags.push(ogMeta('og:image:width', String(img.width)));
+      if (img.height) tags.push(ogMeta('og:image:height', String(img.height)));
+      if (img.type) tags.push(ogMeta('og:image:type', img.type));
+    });
+    if (og.article) {
+      const art = og.article;
+      if (art.publishedTime) tags.push(ogMeta('article:published_time', art.publishedTime));
+      if (art.modifiedTime) tags.push(ogMeta('article:modified_time', art.modifiedTime));
+      if (art.section) tags.push(ogMeta('article:section', art.section));
+      const authors = Array.isArray(art.author) ? art.author : art.author ? [art.author] : [];
+      authors.forEach(a => tags.push(ogMeta('article:author', a)));
+      (_c = art.tags) === null || _c === void 0 ? void 0 : _c.forEach(t => tags.push(ogMeta('article:tag', t)));
+    }
+  }
+  // Twitter Card
+  if (resolved.twitter) {
+    const tw = resolved.twitter;
+    if (tw.card) tags.push(nameMeta('twitter:card', tw.card));
+    if (tw.site) tags.push(nameMeta('twitter:site', tw.site));
+    if (tw.creator) tags.push(nameMeta('twitter:creator', tw.creator));
+    if (tw.title) tags.push(nameMeta('twitter:title', tw.title));
+    if (tw.description) tags.push(nameMeta('twitter:description', tw.description));
+    if (tw.image) tags.push(nameMeta('twitter:image', tw.image));
+    if (tw.imageAlt) tags.push(nameMeta('twitter:image:alt', tw.imageAlt));
+  }
+  // Alternates / hreflang
+  if ((_d = resolved.alternates) === null || _d === void 0 ? void 0 : _d.languages) {
+    Object.entries(resolved.alternates.languages).forEach(([locale, url]) => {
+      tags.push(`<link rel="alternate" hreflang="${escapeAttr(locale)}" href="${escapeAttr(url)}" />`);
+    });
+  }
+  // Icons
+  if (resolved.icons) {
+    collectIconTags(resolved.icons.icon, 'icon', tags);
+    collectIconTags(resolved.icons.apple, 'apple-touch-icon', tags);
+    if (resolved.icons.shortcut) {
+      tags.push(`<link rel="shortcut icon" href="${escapeAttr(resolved.icons.shortcut)}" />`);
+    }
+  }
+  // Manifest
+  if (resolved.manifest) {
+    tags.push(`<link rel="manifest" href="${escapeAttr(resolved.manifest)}" />`);
+  }
+  // Structured data JSON-LD
+  if (resolved.structuredData) {
+    const jsonLd = JSON.stringify(Object.assign({
+      '@context': 'https://schema.org',
+      '@type': resolved.structuredData.type
+    }, resolved.structuredData.schema));
+    tags.push(`<script type="application/ld+json">${jsonLd}</script>`);
+  }
+  // Robots
+  if (resolved.robots || resolved.disableIndexing) {
+    const robots = (_e = resolved.robots) !== null && _e !== void 0 ? _e : {};
+    const noindex = resolved.disableIndexing || robots.noindex;
+    const nofollow = resolved.disableIndexing || robots.nofollow;
+    const robotsValue = [noindex ? 'noindex' : 'index', nofollow ? 'nofollow' : 'follow', robots.noarchive && 'noarchive', robots.nosnippet && 'nosnippet', robots.maxImagePreview && `max-image-preview:${robots.maxImagePreview}`, robots.maxSnippet != null && `max-snippet:${robots.maxSnippet}`].filter(Boolean).join(', ');
+    tags.push(`<meta name="robots" content="${escapeAttr(robotsValue)}" />`);
+  }
+  // Custom meta tags
+  (_f = resolved.customMeta) === null || _f === void 0 ? void 0 : _f.forEach(tag => {
+    if (tag.property) {
+      tags.push(ogMeta(tag.property, tag.content));
+    } else if (tag.name) {
+      tags.push(nameMeta(tag.name, tag.content));
+    } else if (tag.httpEquiv) {
+      tags.push(`<meta http-equiv="${escapeAttr(tag.httpEquiv)}" content="${escapeAttr(tag.content)}" />`);
+    }
+  });
+  return tags.join('\n');
+}
+function collectIconTags(icons, rel, tags) {
+  if (!icons) return;
+  const iconList = typeof icons === 'string' ? [{
+    url: icons
+  }] : Array.isArray(icons) ? icons : [icons];
+  iconList.forEach(icon => {
+    let tag = `<link rel="${rel}" href="${escapeAttr(icon.url)}"`;
+    if (icon.type) tag += ` type="${escapeAttr(icon.type)}"`;
+    if (icon.sizes) tag += ` sizes="${escapeAttr(icon.sizes)}"`;
+    if (icon.color) tag += ` color="${escapeAttr(icon.color)}"`;
+    tag += ' />';
+    tags.push(tag);
+  });
+}
+// ─── HTML helpers ────────────────────────────────────────────
+function escapeHtml(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function ogMeta(property, content) {
+  return `<meta property="${escapeAttr(property)}" content="${escapeAttr(content)}" />`;
+}
+function nameMeta(name, content) {
+  return `<meta name="${escapeAttr(name)}" content="${escapeAttr(content)}" />`;
+}
+// ─── Backward-compatible global API ──────────────────────────
+// These wrap the global store + applyMetadataToDom for existing consumers.
+/**
+ * Apply metadata configuration to the page.
+ * Merges with existing metadata in the global store.
+ * On web: also applies changes to the DOM.
+ *
+ * @deprecated Prefer using `MetadataStoreProvider` + `resolveMetadata` + `applyMetadataToDom`
+ *             for SSR-safe, request-scoped metadata management.
+ */
+const setMetadata = config => {
+  // For backward compat, treat the config as already resolved (strings only).
+  // Evaluator functions should have been resolved by useMetadata before calling this.
+  const resolved = config;
+  globalStore.setMetadata(resolved);
+  if (isWeb) {
+    applyMetadataToDom(resolved);
+  }
+};
+/**
+ * Get current metadata from the global store.
+ * @deprecated Prefer using `MetadataStoreProvider` context in SSR.
+ */
+const getMetadata = () => {
+  return globalStore.getMetadata();
+};
+/**
+ * Reset all metadata in the global store.
+ * @deprecated Prefer using `MetadataStoreProvider` context in SSR.
+ */
+const resetMetadata = () => {
+  globalStore.reset();
+};/**
+ * resolveMetadata — Pure function that evaluates dynamic MetadataConfig into ResolvedMetadata.
+ *
+ * All evaluator functions (title, description, og fields, twitter fields, etc.)
+ * are called with the provided context. The result is a plain object with no functions.
+ *
+ * This function has NO side effects: no DOM, no global state.
+ *
+ * @module config/resolveMetadata
+ */
+/**
+ * Safely evaluate a value that may be a function or a plain value.
+ */
+function evaluate(value, ctx) {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === 'function') {
+    return value(ctx);
+  }
+  return value;
+}
+/**
+ * Resolve a MetadataConfig (which may contain evaluator functions)
+ * into a plain ResolvedMetadata object.
+ *
+ * @param meta - The metadata configuration (static or with dynamic functions)
+ * @param ctx  - The context providing get/set accessors for queries, form, state
+ * @returns Fully resolved metadata with all functions evaluated
+ */
+function resolveMetadata(meta, ctx) {
+  var _a;
+  const resolved = {};
+  // ── Basic fields ────────────────────────────────────────────
+  resolved.title = evaluate(meta.title, ctx);
+  resolved.description = evaluate(meta.description, ctx);
+  resolved.canonical = evaluate(meta.canonical, ctx);
+  // Unify lang / documentLang: prefer `lang`, fall back to deprecated `documentLang`
+  resolved.lang = (_a = meta.lang) !== null && _a !== void 0 ? _a : meta.documentLang;
+  resolved.keywords = evaluate(meta.keywords, ctx);
+  resolved.author = meta.author;
+  resolved.viewport = meta.viewport;
+  resolved.themeColor = meta.themeColor;
+  resolved.disableIndexing = meta.disableIndexing;
+  // ── Open Graph ──────────────────────────────────────────────
+  if (meta.openGraph) {
+    const og = meta.openGraph;
+    const resolvedImage = evaluate(og.image, ctx);
+    const resolvedImages = evaluate(og.images, ctx);
+    resolved.openGraph = {
+      type: og.type,
+      title: evaluate(og.title, ctx),
+      description: evaluate(og.description, ctx),
+      image: resolvedImage,
+      images: resolvedImages,
+      url: evaluate(og.url, ctx),
+      siteName: og.siteName,
+      locale: og.locale,
+      article: og.article
+    };
+    // Normalize: if single image string, also put it in images array
+    if (resolvedImage && !resolvedImages) {
+      const imgObj = typeof resolvedImage === 'string' ? {
+        url: resolvedImage
+      } : resolvedImage;
+      resolved.openGraph.images = [imgObj];
+    }
+  }
+  // ── Twitter Card ────────────────────────────────────────────
+  if (meta.twitter) {
+    const tw = meta.twitter;
+    resolved.twitter = {
+      card: tw.card,
+      site: tw.site,
+      creator: tw.creator,
+      title: evaluate(tw.title, ctx),
+      description: evaluate(tw.description, ctx),
+      image: evaluate(tw.image, ctx),
+      imageAlt: evaluate(tw.imageAlt, ctx)
+    };
+  }
+  // ── Alternates / hreflang ───────────────────────────────────
+  if (meta.alternates) {
+    resolved.alternates = Object.assign({}, meta.alternates);
+  }
+  // ── Icons / PWA ─────────────────────────────────────────────
+  if (meta.icons) {
+    resolved.icons = Object.assign({}, meta.icons);
+  }
+  if (meta.manifest) {
+    resolved.manifest = meta.manifest;
+  }
+  // ── Structured Data ─────────────────────────────────────────
+  if (meta.structuredData) {
+    const sd = meta.structuredData;
+    resolved.structuredData = {
+      type: sd.type,
+      schema: typeof sd.schema === 'function' ? sd.schema(ctx) : sd.schema
+    };
+  }
+  // ── AI Hints ────────────────────────────────────────────────
+  if (meta.aiHints) {
+    const hints = meta.aiHints;
+    resolved.aiHints = {
+      contentClassification: evaluate(hints.contentClassification, ctx),
+      modelHints: evaluate(hints.modelHints, ctx),
+      contextualInfo: evaluate(hints.contextualInfo, ctx),
+      excludeFromIndexing: hints.excludeFromIndexing
+    };
+  }
+  // ── Robots ──────────────────────────────────────────────────
+  if (meta.robots) {
+    resolved.robots = Object.assign({}, meta.robots);
+  }
+  // ── Custom Meta Tags ───────────────────────────────────────
+  const customMeta = evaluate(meta.customMeta, ctx);
+  if (customMeta) {
+    resolved.customMeta = customMeta;
+  }
+  return resolved;
+}const MetadataStoreContext = React.createContext(null);
+/**
+ * Provides a request-scoped MetadataStore via React Context.
+ *
+ * @example SSR (one per request)
+ * ```tsx
+ * import { createMetadataStore, MetadataStoreProvider } from '@/core/pages';
+ *
+ * function handleRequest(req, res) {
+ *   const store = createMetadataStore();
+ *   const html = renderToString(
+ *     <MetadataStoreProvider store={store}>
+ *       <App />
+ *     </MetadataStoreProvider>
+ *   );
+ *   const headHtml = collectMetadataToHtml(store.getMetadata());
+ *   // inject headHtml into <head>
+ * }
+ * ```
+ */
+function MetadataStoreProvider(t0) {
+  const $ = compilerRuntime.c(5);
+  const {
+    store,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== store) {
+    t1 = store !== null && store !== void 0 ? store : createMetadataStore();
+    $[0] = store;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const value = t1;
+  let t2;
+  if ($[2] !== children || $[3] !== value) {
+    t2 = jsxRuntime.jsx(MetadataStoreContext.Provider, {
+      value,
+      children
+    });
+    $[2] = children;
+    $[3] = value;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+}
+/**
+ * Access the nearest request-scoped MetadataStore.
+ * Returns `null` if no provider is found (falls back to global store in consumers).
+ */
+function useMetadataStore() {
+  return React.useContext(MetadataStoreContext);
+}/**
+ * Optional dev-only metadata logging.
+ *
+ * Tracks what metadata was resolved and applied, useful for debugging
+ * metadata issues during development.
+ *
+ * Logging is a no-op in production builds.
+ *
+ * @module config/metadataLogger
+ */
+const isDev = process.env.NODE_ENV === 'development';
+let logEnabled = false;
+const logEntries = [];
+/**
+ * Enable or disable metadata logging.
+ * Only effective in development mode.
+ */
+function setMetadataLogging(enabled) {
+  logEnabled = isDev && enabled;
+}
+/**
+ * Log a metadata action (resolve, apply, translate).
+ * No-op in production or when logging is disabled.
+ */
+function logMetadata(pageId, action, metadata) {
+  if (!logEnabled) return;
+  const entry = {
+    pageId,
+    action,
+    metadata,
+    timestamp: Date.now()
+  };
+  logEntries.push(entry);
+  // Keep only last 50 entries to avoid memory leaks
+  if (logEntries.length > 50) {
+    logEntries.splice(0, logEntries.length - 50);
+  }
+  console.log(`[Metadata:${action}] page="${pageId}"`, metadata.title ? `title="${metadata.title}"` : '', metadata.description ? `desc="${metadata.description.slice(0, 60)}..."` : '');
+}
+/**
+ * Get all logged metadata entries (dev only).
+ * Useful for inspecting metadata in browser devtools.
+ */
+function getMetadataLog() {
+  return [...logEntries];
+}
+/**
+ * Clear the metadata log.
+ */
+function clearMetadataLog() {
+  logEntries.length = 0;
+}const DefaultContainer = ({
+  children
+}) => {
+  return children;
+};
+// Lazy initialization to avoid side effects at module load time
+// This ensures tree-shaking works correctly by deferring singleton creation
+let _pageConfig = {
+  HeaderContainer: DefaultContainer,
+  FooterContainer: DefaultContainer,
+  BodyContainer: DefaultContainer,
+  authPageImage: '',
+  authPageProps: {
+    id: 'auth-page'
+  },
+  isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
+  ItemsContainer: ({
+    children
+  }) => children,
+  PageContainer: ({
+    children
+  }) => children,
+  meta: {
+    title: '',
+    description: ''
+  },
+  // Metadata configuration
+  defaultMetadata: {},
+  setMetadata,
+  getMetadata,
+  resetMetadata,
+  // Lazy loading configuration
+  lazyLoading: {
+    enabled: true,
+    preloadOnHover: false,
+    preloadOnFocus: false,
+    timeout: 30000,
+    logMetrics: process.env.NODE_ENV === 'development'
+  }
+};
+/**
+ * Get or initialize the page configuration singleton
+ * Uses lazy initialization to avoid module-level side effects for better tree-shaking
+ */
+function initializePageConfig() {
+  _pageConfig = {
+    HeaderContainer: DefaultContainer,
+    FooterContainer: DefaultContainer,
+    BodyContainer: DefaultContainer,
+    authPageImage: '',
+    authPageProps: {
+      id: 'auth-page'
+    },
+    isLogged: val => !!(val === null || val === void 0 ? void 0 : val.id) && !!val.isLogged,
+    ItemsContainer: ({
+      children
+    }) => children,
+    PageContainer: ({
+      children
+    }) => children,
+    meta: {
+      title: '',
+      description: ''
+    },
+    // Metadata configuration
+    defaultMetadata: {},
+    setMetadata,
+    getMetadata,
+    resetMetadata,
+    // Lazy loading configuration
+    lazyLoading: {
+      enabled: true,
+      preloadOnHover: false,
+      preloadOnFocus: false,
+      timeout: 30000,
+      logMetrics: process.env.NODE_ENV === 'development'
+    }
+  };
+  return _pageConfig;
+}
+// Getter for pageConfig - initializes on first access
+function getPageConfig() {
+  return initializePageConfig();
+}
+const {
+  atom: pageConfigAtom,
+  useValue: usePageConfigValue,
+  useState: usePageConfigState,
+  useReset: usePageConfigReset
+} = reactState.atomStateGenerator({
+  key: 'pageConfig',
+  defaultValue: _pageConfig,
+  persist: false
+});/**
+ * Specialized hook for managing view settings
+ * Optimized to prevent unnecessary re-renders
+ * @param viewSettings - View settings configuration (static or function)
+ * @param allQuery - All query results
+ * @param allMutation - All mutation handlers
+ * @param formValues - Current form values
+ * @param setValue - Form setValue function
+ * @returns Processed view settings
+ */
+function useViewSettings(t0) {
+  const $ = compilerRuntime.c(2);
+  const {
+    viewSettings: t1,
+    pageId
+  } = t0;
+  const viewSettings = t1 === undefined ? {} : t1;
+  let t2;
+  if ($[0] !== pageId) {
+    t2 = {
+      pageId
+    };
+    $[0] = pageId;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const {
+    get,
+    set
+  } = usePageValues(t2);
+  if (typeof viewSettings === "function") {
+    return viewSettings({
+      get,
+      set
+    });
+  } else {
+    return viewSettings;
+  }
+}/**
+ * Specialized hook for managing form data processing
+ * Uses useMemo to prevent unnecessary re-computation
+ * @param form - Form configuration
+ * @param isAllQueryMapped - Whether all queries are mapped
+ * @param formValues - Current form values
+ * @param extractMutationsHandle - Extracted mutations
+ * @param extractQueryHandle - Extracted queries
+ * @param setValue - Form setValue function
+ * @returns Processed form data and submit handlers
+ */
+function useFormData({
+  form,
+  pageId
+}) {
+  const {
+    get,
+    set
+  } = usePageValues({
+    pageId
+  });
+  const hiddenMapped = React.useCallback(() => {
+    const isHidden = form === null || form === void 0 ? void 0 : form.hidden;
+    if (!isHidden) return false;
+    if (typeof isHidden === 'function') {
+      return isHidden({
+        get,
+        set
+      });
+    } else {
+      return !!isHidden;
+    }
+  }, [form === null || form === void 0 ? void 0 : form.hidden, get, set]);
+  const mappedFormData = React.useMemo(() => {
+    if (!(form === null || form === void 0 ? void 0 : form.data) || hiddenMapped()) return [];
+    return form.data.map(el => {
+      if (typeof el === 'function') {
+        return el({
+          get,
+          set
+        });
+      }
+      return el;
+    })
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    .filter(el_0 => !!el_0).map((el_1, i) => {
+      var _a;
+      return Object.assign(Object.assign({}, el_1), {
+        key: (_a = el_1.key) !== null && _a !== void 0 ? _a : `${i}`
+      });
+    });
+  }, [form, get, hiddenMapped, set]);
+  const formSubmit = React.useMemo(() => {
+    if (!(form === null || form === void 0 ? void 0 : form.submit) || hiddenMapped()) return [];
+    const submitFn = form.submit;
+    return (typeof submitFn === 'function' ? submitFn({
+      get,
+      set
+    }) : submitFn).map((el_2, i_0) => {
+      var _a_0;
+      return Object.assign(Object.assign({}, el_2), {
+        key: (_a_0 = el_2.key) !== null && _a_0 !== void 0 ? _a_0 : `${i_0}`
+      });
+    });
+  }, [form, hiddenMapped, get, set]);
+  return {
+    mappedFormData,
+    formSubmit
+  };
+}// src/subscribable.ts
+var Subscribable = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(listener);
+      this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {}
+  onUnsubscribe() {}
+};// src/timeoutManager.ts
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: timeoutId => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: intervalId => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #provider = defaultTimeoutProvider;
+  #providerCalled = false;
+  setTimeoutProvider(provider) {
+    if (process.env.NODE_ENV !== "production") {
+      if (this.#providerCalled && provider !== this.#provider) {
+        console.error(`[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, {
+          previous: this.#provider,
+          provider
+        });
+      }
+    }
+    this.#provider = provider;
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = false;
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    this.#provider.clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    this.#provider.clearInterval(intervalId);
+  }
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}// src/utils.ts
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {}
+function isValidTimeout(value) {
+  return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+  return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+  return typeof enabled === "function" ? enabled(query) : enabled;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b) {
+  if (a === b) {
+    return a;
+  }
+  const array = isPlainArray(a) && isPlainArray(b);
+  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+  const aItems = array ? a : Object.keys(a);
+  const aSize = aItems.length;
+  const bItems = array ? b : Object.keys(b);
+  const bSize = bItems.length;
+  const copy = array ? new Array(bSize) : {};
+  let equalItems = 0;
+  for (let i = 0; i < bSize; i++) {
+    const key = array ? i : bItems[i];
+    const aItem = a[key];
+    const bItem = b[key];
+    if (aItem === bItem) {
+      copy[key] = aItem;
+      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+      continue;
+    }
+    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+      copy[key] = bItem;
+      continue;
+    }
+    const v = replaceEqualDeep(aItem, bItem);
+    copy[key] = v;
+    if (v === aItem) equalItems++;
+  }
+  return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error) {
+        console.error(`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`);
+        throw error;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}// src/focusManager.ts
+var FocusManager = class extends Subscribable {
+  #focused;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = onFocus => {
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup(focused => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    });
+  }
+  setFocused(focused) {
+    const changed = this.#focused !== focused;
+    if (changed) {
+      this.#focused = focused;
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach(listener => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    if (typeof this.#focused === "boolean") {
+      return this.#focused;
+    }
+    return globalThis.document?.visibilityState !== "hidden";
+  }
+};
+var focusManager = new FocusManager();// src/thenable.ts
+function pendingThenable() {
+  let resolve;
+  let reject;
+  const thenable = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  thenable.status = "pending";
+  thenable.catch(() => {});
+  function finalize(data) {
+    Object.assign(thenable, data);
+    delete thenable.resolve;
+    delete thenable.reject;
+  }
+  thenable.resolve = value => {
+    finalize({
+      status: "fulfilled",
+      value
+    });
+    resolve(value);
+  };
+  thenable.reject = reason => {
+    finalize({
+      status: "rejected",
+      reason
+    });
+    reject(reason);
+  };
+  return thenable;
+}// src/notifyManager.ts
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = callback => {
+    callback();
+  };
+  let batchNotifyFn = callback => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = callback => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach(callback => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: callback => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: callback => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: fn => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: fn => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: fn => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();// src/onlineManager.ts
+var OnlineManager = class extends Subscribable {
+  #online = true;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = onOnline => {
+      if (!isServer && window.addEventListener) {
+        const onlineListener = () => onOnline(true);
+        const offlineListener = () => onOnline(false);
+        window.addEventListener("online", onlineListener, false);
+        window.addEventListener("offline", offlineListener, false);
+        return () => {
+          window.removeEventListener("online", onlineListener);
+          window.removeEventListener("offline", offlineListener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup(this.setOnline.bind(this));
+  }
+  setOnline(online) {
+    const changed = this.#online !== online;
+    if (changed) {
+      this.#online = online;
+      this.listeners.forEach(listener => {
+        listener(online);
+      });
+    }
+  }
+  isOnline() {
+    return this.#online;
+  }
+};
+var onlineManager = new OnlineManager();// src/retryer.ts
+function canFetch(networkMode) {
+  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}// src/query.ts
+function fetchState(data, options) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+    ...(data === void 0 && {
+      error: null,
+      status: "pending"
+    })
+  };
+}// src/queryObserver.ts
+var QueryObserver = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.options = options;
+    this.#client = client;
+    this.#selectError = null;
+    this.#currentThenable = pendingThenable();
+    this.bindMethods();
+    this.setOptions(options);
+  }
+  #client;
+  #currentQuery = void 0;
+  #currentQueryInitialState = void 0;
+  #currentResult = void 0;
+  #currentResultState;
+  #currentResultOptions;
+  #currentThenable;
+  #selectError;
+  #selectFn;
+  #selectResult;
+  // This property keeps track of the last query with defined data.
+  // It will be used to pass the previous data and query to the placeholder function between renders.
+  #lastQueryWithDefinedData;
+  #staleTimeoutId;
+  #refetchIntervalId;
+  #currentRefetchInterval;
+  #trackedProps = /* @__PURE__ */new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.#currentQuery.addObserver(this);
+      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
+        this.#executeFetch();
+      } else {
+        this.updateResult();
+      }
+      this.#updateTimers();
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
+  }
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */new Set();
+    this.#clearStaleTimeout();
+    this.#clearRefetchInterval();
+    this.#currentQuery.removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = this.#currentQuery;
+    this.options = this.#client.defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") {
+      throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
+    }
+    this.#updateQuery();
+    this.#currentQuery.setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      this.#client.getQueryCache().notify({
+        type: "observerOptionsUpdated",
+        query: this.#currentQuery,
+        observer: this
+      });
+    }
+    const mounted = this.hasListeners();
+    if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) {
+      this.#executeFetch();
+    }
+    this.updateResult();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) {
+      this.#updateStaleTimeout();
+    }
+    const nextRefetchInterval = this.#computeRefetchInterval();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
+      this.#updateRefetchInterval(nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = this.#client.getQueryCache().build(this.#client, options);
+    const result = this.createResult(query, options);
+    if (shouldAssignObserverCurrentProperties(this, result)) {
+      this.#currentResult = result;
+      this.#currentResultOptions = this.options;
+      this.#currentResultState = this.#currentQuery.state;
+    }
+    return result;
+  }
+  getCurrentResult() {
+    return this.#currentResult;
+  }
+  trackResult(result, onPropTracked) {
+    return new Proxy(result, {
+      get: (target, key) => {
+        this.trackProp(key);
+        onPropTracked?.(key);
+        if (key === "promise") {
+          this.trackProp("data");
+          if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
+            this.#currentThenable.reject(new Error("experimental_prefetchInRender feature flag is not enabled"));
+          }
+        }
+        return Reflect.get(target, key);
+      }
+    });
+  }
+  trackProp(key) {
+    this.#trackedProps.add(key);
+  }
+  getCurrentQuery() {
+    return this.#currentQuery;
+  }
+  refetch({
+    ...options
+  } = {}) {
+    return this.fetch({
+      ...options
+    });
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = this.#client.defaultQueryOptions(options);
+    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    return this.#executeFetch({
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
+    }).then(() => {
+      this.updateResult();
+      return this.#currentResult;
+    });
+  }
+  #executeFetch(fetchOptions) {
+    this.#updateQuery();
+    let promise = this.#currentQuery.fetch(this.options, fetchOptions);
+    if (!fetchOptions?.throwOnError) {
+      promise = promise.catch(noop);
+    }
+    return promise;
+  }
+  #updateStaleTimeout() {
+    this.#clearStaleTimeout();
+    const staleTime = resolveStaleTime(this.options.staleTime, this.#currentQuery);
+    if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
+      return;
+    }
+    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime);
+    const timeout = time + 1;
+    this.#staleTimeoutId = timeoutManager.setTimeout(() => {
+      if (!this.#currentResult.isStale) {
+        this.updateResult();
+      }
+    }, timeout);
+  }
+  #computeRefetchInterval() {
+    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
+  }
+  #updateRefetchInterval(nextInterval) {
+    this.#clearRefetchInterval();
+    this.#currentRefetchInterval = nextInterval;
+    if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
+      return;
+    }
+    this.#refetchIntervalId = timeoutManager.setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        this.#executeFetch();
+      }
+    }, this.#currentRefetchInterval);
+  }
+  #updateTimers() {
+    this.#updateStaleTimeout();
+    this.#updateRefetchInterval(this.#computeRefetchInterval());
+  }
+  #clearStaleTimeout() {
+    if (this.#staleTimeoutId) {
+      timeoutManager.clearTimeout(this.#staleTimeoutId);
+      this.#staleTimeoutId = void 0;
+    }
+  }
+  #clearRefetchInterval() {
+    if (this.#refetchIntervalId) {
+      timeoutManager.clearInterval(this.#refetchIntervalId);
+      this.#refetchIntervalId = void 0;
+    }
+  }
+  createResult(query, options) {
+    const prevQuery = this.#currentQuery;
+    const prevOptions = this.options;
+    const prevResult = this.#currentResult;
+    const prevResultState = this.#currentResultState;
+    const prevResultOptions = this.#currentResultOptions;
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
+    const {
+      state
+    } = query;
+    let newState = {
+      ...state
+    };
+    let isPlaceholderData = false;
+    let data;
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let {
+      error,
+      errorUpdatedAt,
+      status
+    } = newState;
+    data = newState.data;
+    let skipSelect = false;
+    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+        placeholderData = prevResult.data;
+        skipSelect = true;
+      } else {
+        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
+      }
+      if (placeholderData !== void 0) {
+        status = "success";
+        data = replaceData(prevResult?.data, placeholderData, options);
+        isPlaceholderData = true;
+      }
+    }
+    if (options.select && data !== void 0 && !skipSelect) {
+      if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) {
+        data = this.#selectResult;
+      } else {
+        try {
+          this.#selectFn = options.select;
+          data = options.select(data);
+          data = replaceData(prevResult?.data, data, options);
+          this.#selectResult = data;
+          this.#selectError = null;
+        } catch (selectError) {
+          this.#selectError = selectError;
+        }
+      }
+    }
+    if (this.#selectError) {
+      error = this.#selectError;
+      data = this.#selectResult;
+      errorUpdatedAt = Date.now();
+      status = "error";
+    }
+    const isFetching = newState.fetchStatus === "fetching";
+    const isPending = status === "pending";
+    const isError = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError,
+      isInitialLoading: isLoading,
+      isLoading,
+      data,
+      dataUpdatedAt: newState.dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
+      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isPending,
+      isLoadingError: isError && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError && hasData,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      promise: this.#currentThenable,
+      isEnabled: resolveEnabled(options.enabled, query) !== false
+    };
+    const nextResult = result;
+    if (this.options.experimental_prefetchInRender) {
+      const finalizeThenableIfPossible = thenable => {
+        if (nextResult.status === "error") {
+          thenable.reject(nextResult.error);
+        } else if (nextResult.data !== void 0) {
+          thenable.resolve(nextResult.data);
+        }
+      };
+      const recreateThenable = () => {
+        const pending = this.#currentThenable = nextResult.promise = pendingThenable();
+        finalizeThenableIfPossible(pending);
+      };
+      const prevThenable = this.#currentThenable;
+      switch (prevThenable.status) {
+        case "pending":
+          if (query.queryHash === prevQuery.queryHash) {
+            finalizeThenableIfPossible(prevThenable);
+          }
+          break;
+        case "fulfilled":
+          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+            recreateThenable();
+          }
+          break;
+        case "rejected":
+          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+            recreateThenable();
+          }
+          break;
+      }
+    }
+    return nextResult;
+  }
+  updateResult() {
+    const prevResult = this.#currentResult;
+    const nextResult = this.createResult(this.#currentQuery, this.options);
+    this.#currentResultState = this.#currentQuery.state;
+    this.#currentResultOptions = this.options;
+    if (this.#currentResultState.data !== void 0) {
+      this.#lastQueryWithDefinedData = this.#currentQuery;
+    }
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+    this.#currentResult = nextResult;
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+      const {
+        notifyOnChangeProps
+      } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) {
+        return true;
+      }
+      const includedProps = new Set(notifyOnChangePropsValue ?? this.#trackedProps);
+      if (this.options.throwOnError) {
+        includedProps.add("error");
+      }
+      return Object.keys(this.#currentResult).some(key => {
+        const typedKey = key;
+        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+    this.#notify({
+      listeners: shouldNotifyListeners()
+    });
+  }
+  #updateQuery() {
+    const query = this.#client.getQueryCache().build(this.#client, this.options);
+    if (query === this.#currentQuery) {
+      return;
+    }
+    const prevQuery = this.#currentQuery;
+    this.#currentQuery = query;
+    this.#currentQueryInitialState = query.state;
+    if (this.hasListeners()) {
+      prevQuery?.removeObserver(this);
+      query.addObserver(this);
+    }
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      this.#updateTimers();
+    }
+  }
+  #notify(notifyOptions) {
+    notifyManager.batch(() => {
+      if (notifyOptions.listeners) {
+        this.listeners.forEach(listener => {
+          listener(this.#currentResult);
+        });
+      }
+      this.#client.getQueryCache().notify({
+        query: this.#currentQuery,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function shouldLoadOnMount(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+  if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}const usePageFormManager = ({
+  form,
+  pageId,
+  ns
+}) => {
+  var _a_0;
+  const {
+    queryClient
+  } = reactQueries.useApiConfigValue();
+  const [defaultValueQuery, setDefaultValueQuery] = React.useState(form === null || form === void 0 ? void 0 : form.defaultValues);
+  React.useEffect(() => {
+    if (!(form === null || form === void 0 ? void 0 : form.defaultValueQueryKey)) {
+      // setDefaultValueQuery(form?.defaultValues)
+      return;
+    }
+    queryClient.getQueryData(form.defaultValueQueryKey);
+    const observer = new QueryObserver(queryClient, {
+      queryKey: form.defaultValueQueryKey,
+      enabled: true,
+      notifyOnChangeProps: ["data"],
+      refetchOnWindowFocus: false
+    });
+    const unsubscribe = observer.subscribe(result => {
+      if (result.data !== undefined) {
+        setDefaultValueQuery(result.data);
+      }
+    });
+    return () => unsubscribe();
+  }, [form === null || form === void 0 ? void 0 : form.defaultValueQueryKey, form === null || form === void 0 ? void 0 : form.defaultValues, queryClient]);
+  const defaultValues = React.useMemo(() => {
+    var _a, _b;
+    return Object.assign(Object.assign({}, defaultValueQuery !== null && defaultValueQuery !== void 0 ? defaultValueQuery : {}), (_b = (_a = form === null || form === void 0 ? void 0 : form.defaultValueQueryMap) === null || _a === void 0 ? void 0 : _a.call(form, defaultValueQuery)) !== null && _b !== void 0 ? _b : {});
+  }, [defaultValueQuery, form]);
+  const {
+    mappedFormData,
+    formSubmit
+  } = useFormData({
+    form,
+    pageId
+  });
+  // Call useFormManager hook at top level (maintains hook order)
+  const rawFormData = reactForm.useFormManager(Object.assign(Object.assign({}, form), {
+    data: mappedFormData,
+    ns,
+    submit: formSubmit,
+    id: pageId,
+    formOptions: Object.assign(Object.assign({
+      defaultValues: defaultValues
+    }, (_a_0 = form === null || form === void 0 ? void 0 : form.formSettings) !== null && _a_0 !== void 0 ? _a_0 : {}), {
+      formId: pageId
+    })
+  }));
+  const formData = React.useMemo(() => Object.assign(Object.assign({}, rawFormData), {
+    formContents: rawFormData.formContents
+  }), [rawFormData]);
+  return {
+    formData
+  };
+};const EMPTY_ARRAY = [];
+const usePageConfig = t0 => {
+  const $ = compilerRuntime.c(28);
+  const {
+    queries: t1,
+    form,
+    ns,
+    viewSettings: t2,
+    meta,
+    lazyLoading,
+    variables,
+    pageId
+  } = t0;
+  const queries = t1 === undefined ? EMPTY_ARRAY : t1;
+  let t3;
+  if ($[0] !== t2) {
+    t3 = t2 === undefined ? {} : t2;
+    $[0] = t2;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const viewSettings = t3;
+  const globalConfig = usePageConfigValue();
+  let t4;
+  if ($[2] !== form || $[3] !== ns || $[4] !== pageId) {
+    t4 = {
+      form,
+      pageId,
+      ns
+    };
+    $[2] = form;
+    $[3] = ns;
+    $[4] = pageId;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  const {
+    formData
+  } = usePageFormManager(t4);
+  let t5;
+  if ($[6] !== pageId || $[7] !== variables) {
+    t5 = {
+      pageId,
+      initialValues: variables
+    };
+    $[6] = pageId;
+    $[7] = variables;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  const {
+    get,
+    set
+  } = usePageValues(t5);
+  let t6;
+  if ($[9] !== get || $[10] !== queries || $[11] !== set) {
+    let t7;
+    if ($[13] !== get || $[14] !== set) {
+      t7 = q => {
+        if (q.type === "mutation") {
+          const mutationConfig = typeof q.mutationConfig === "function" ? q.mutationConfig({
+            get,
+            set
+          }) : q.mutationConfig;
+          return Object.assign(Object.assign({}, q), {
+            mutationConfig
+          });
+        } else {
+          if (q.type === "query") {
+            const queryConfig = typeof q.queryConfig === "function" ? q.queryConfig({
+              get,
+              set
+            }) : q.queryConfig;
+            return Object.assign(Object.assign({}, q), {
+              queryConfig
+            });
+          }
+        }
+        return q;
+      };
+      $[13] = get;
+      $[14] = set;
+      $[15] = t7;
+    } else {
+      t7 = $[15];
+    }
+    t6 = queries.map(t7);
+    $[9] = get;
+    $[10] = queries;
+    $[11] = set;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  const processedQueries = t6;
+  let t7;
+  if ($[16] !== pageId) {
+    t7 = {
+      persistToAtoms: true,
+      scopeId: pageId
+    };
+    $[16] = pageId;
+    $[17] = t7;
+  } else {
+    t7 = $[17];
+  }
+  reactQueries.useApi(processedQueries, t7);
+  let t8;
+  if ($[18] !== pageId || $[19] !== viewSettings) {
+    t8 = {
+      viewSettings,
+      pageId
+    };
+    $[18] = pageId;
+    $[19] = viewSettings;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  const mappedViewSettings = useViewSettings(t8);
+  let t9;
+  if ($[21] !== form || $[22] !== formData || $[23] !== globalConfig || $[24] !== lazyLoading || $[25] !== mappedViewSettings || $[26] !== meta) {
+    t9 = {
+      formData,
+      form,
+      mappedViewSettings,
+      meta,
+      lazyLoading,
+      globalConfig
+    };
+    $[21] = form;
+    $[22] = formData;
+    $[23] = globalConfig;
+    $[24] = lazyLoading;
+    $[25] = mappedViewSettings;
+    $[26] = meta;
+    $[27] = t9;
+  } else {
+    t9 = $[27];
+  }
+  const mergedConfig = t9;
+  return mergedConfig;
+};/**
+ * Hook for evaluating and managing dynamic metadata.
+ *
+ * Pipeline:
+ * 1. Evaluate `meta` (if it's a MappedItemsFunction, call it with get/set)
+ * 2. Resolve all dynamic functions via `resolveMetadata()`
+ * 3. Translate strings via i18n
+ * 4. Auto-apply to DOM (client) or store (SSR) via `applyMetadataToDom` / MetadataStore
+ *
+ * @returns Resolved and translated metadata
+ */
+function useMetadata({
+  meta,
+  autoApply = true,
+  pageId
+}) {
+  const {
+    translateText,
+    locale
+  } = usePageConfigValue();
+  const t = React.useMemo(() => translateText !== null && translateText !== void 0 ? translateText : key => key, [translateText]);
+  const {
+    get,
+    set
+  } = usePageValues({
+    pageId
+  });
+  const metadataStore = useMetadataStore();
+  // Step 1: Evaluate metadata (if function)
+  const evaluatedMeta = React.useMemo(() => {
+    if (!meta) return {};
+    if (typeof meta === 'function') {
+      return meta({
+        get,
+        set
+      });
+    }
+    return meta;
+  }, [meta, get, set]);
+  // Step 2: Resolve all dynamic evaluator functions into plain values
+  const resolved = React.useMemo(() => resolveMetadata(evaluatedMeta, {
+    get,
+    set
+  }), [evaluatedMeta, get, set]);
+  // Step 3: Translate metadata strings (i18n)
+  const translated = React.useMemo(() => {
+    var _a;
+    const result = Object.assign({}, resolved);
+    // Translate basic fields
+    if (result.title) {
+      result.title = t(result.title, {
+        ns: 'meta',
+        defaultValue: result.title
+      });
+    }
+    if (result.description) {
+      result.description = t(result.description, {
+        ns: 'meta',
+        defaultValue: result.description
+      });
+    }
+    if (result.keywords) {
+      result.keywords = result.keywords.map(kw => t(kw, {
+        ns: 'meta',
+        defaultValue: kw
+      }));
+    }
+    if (result.author) {
+      result.author = t(result.author, {
+        ns: 'meta',
+        defaultValue: result.author
+      });
+    }
+    // Translate Open Graph
+    if (result.openGraph) {
+      result.openGraph = Object.assign({}, result.openGraph);
+      if (result.openGraph.title) {
+        result.openGraph.title = t(result.openGraph.title, {
+          ns: 'meta',
+          defaultValue: result.openGraph.title
+        });
+      }
+      if (result.openGraph.description) {
+        result.openGraph.description = t(result.openGraph.description, {
+          ns: 'meta',
+          defaultValue: result.openGraph.description
+        });
+      }
+      if (result.openGraph.siteName) {
+        result.openGraph.siteName = t(result.openGraph.siteName, {
+          ns: 'meta',
+          defaultValue: result.openGraph.siteName
+        });
+      }
+    }
+    // Translate Twitter Card
+    if (result.twitter) {
+      result.twitter = Object.assign({}, result.twitter);
+      if (result.twitter.title) {
+        result.twitter.title = t(result.twitter.title, {
+          ns: 'meta',
+          defaultValue: result.twitter.title
+        });
+      }
+      if (result.twitter.description) {
+        result.twitter.description = t(result.twitter.description, {
+          ns: 'meta',
+          defaultValue: result.twitter.description
+        });
+      }
+    }
+    // Set language from locale
+    result.lang = (_a = result.lang) !== null && _a !== void 0 ? _a : locale;
+    return result;
+  }, [resolved, t, locale]);
+  // Step 4: Apply metadata
+  React.useEffect(() => {
+    if (!autoApply) return;
+    // If we have a request-scoped store (SSR), write to it
+    if (metadataStore) {
+      metadataStore.setMetadata(translated);
+    }
+    // On the client, also apply to DOM
+    if (typeof document !== 'undefined') {
+      applyMetadataToDom(translated);
+    }
+  }, [translated, autoApply, metadataStore]);
+  return translated;
+}
+/**
+ * Hook to manually apply metadata (when autoApply is false)
+ * @returns Function to apply resolved metadata to the DOM
+ */
+function useApplyMetadata() {
+  const $ = compilerRuntime.c(2);
+  const metadataStore = useMetadataStore();
+  let t0;
+  if ($[0] !== metadataStore) {
+    t0 = meta => {
+      if (metadataStore) {
+        metadataStore.setMetadata(meta);
+      }
+      if (typeof document !== "undefined") {
+        applyMetadataToDom(meta);
+      }
+    };
+    $[0] = metadataStore;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}/**
+ * Headless component that manages metadata injection.
+ * On web: injects metadata into `<head>`.
+ * On SSR: stores metadata in the request-scoped MetadataStore (via context).
+ * On React Native: metadata is resolved but not applied to DOM.
+ *
+ * @example
+ * ```tsx
+ * <MetadataManager
+ *   meta={{
+ *     title: 'My Page',
+ *     description: 'Page description',
+ *     openGraph: { type: 'website', image: '/og.png' },
+ *     twitter: { card: 'summary_large_image' },
+ *   }}
+ *   pageId="my-page"
+ * />
+ * ```
+ */
+const MetadataManagerImpl = t0 => {
+  const $ = compilerRuntime.c(4);
+  const {
+    meta,
+    ns: t1,
+    pageId
+  } = t0;
+  const ns = t1 === undefined ? "common" : t1;
+  let t2;
+  if ($[0] !== meta || $[1] !== ns || $[2] !== pageId) {
+    t2 = {
+      meta,
+      ns,
+      pageId
+    };
+    $[0] = meta;
+    $[1] = ns;
+    $[2] = pageId;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  useMetadata(t2);
+  return null;
+};
+MetadataManagerImpl.displayName = 'MetadataManager';
+const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
+  var {
+      enableAuthControl = true,
+      meta,
+      variables
+    } = _a,
+    props = __rest(_a, ["enableAuthControl", "meta", "variables"]);
+  const {
+    BodyContainer,
+    FooterContainer,
+    HeaderContainer,
+    PageContainer,
+    isLogged,
+    authValues,
+    authPageProps
+  } = usePageConfigValue();
+  const isUnlogged = React.useMemo(() => enableAuthControl && !isLogged(authValues ? authValues : null), [enableAuthControl, authValues, isLogged]);
+  const selectedProps = React.useMemo(() => {
+    return enableAuthControl && isUnlogged ? authPageProps : props;
+  }, [enableAuthControl, isUnlogged, authPageProps, props]);
+  const {
+    contents = [],
+    queries = [],
+    form,
+    id = 'default-page-id',
+    viewSettings,
+    ns
+  } = React.useMemo(() => selectedProps, [selectedProps]);
+  const config = usePageConfig({
+    queries,
+    form,
+    ns: ns !== null && ns !== void 0 ? ns : '',
+    viewSettings,
+    pageId: id,
+    variables
+  });
+  const {
+    mappedViewSettings
+  } = config;
+  const {
+    allContents,
+    body,
+    footer,
+    header
+  } = useGenerateContent({
+    contents,
+    pageId: id,
+    ns,
+    pageConfig: config
+  });
+  const LayoutComponent = React.useMemo(() => {
+    var _a_0;
+    return (_a_0 = mappedViewSettings.layoutComponent) !== null && _a_0 !== void 0 ? _a_0 : BodyContainer;
+  }, [mappedViewSettings.layoutComponent, BodyContainer]);
+  const layoutProps = React.useMemo(() => {
+    var _a_1;
+    return (_a_1 = mappedViewSettings.layoutProps) !== null && _a_1 !== void 0 ? _a_1 : {};
+  }, [mappedViewSettings.layoutProps]);
+  const PageContainerComponent = React.useMemo(() => {
+    var _a_2;
+    return (_a_2 = mappedViewSettings.pageContainerComponent) !== null && _a_2 !== void 0 ? _a_2 : PageContainer;
+  }, [mappedViewSettings.pageContainerComponent, PageContainer]);
+  const pageContainerProps = React.useMemo(() => {
+    var _a_3;
+    return (_a_3 = mappedViewSettings.pageContainerProps) !== null && _a_3 !== void 0 ? _a_3 : {};
+  }, [mappedViewSettings.pageContainerProps]);
+  const layoutBody = React.useMemo(() => body, [body]);
+  const store = useStore();
+  const refreshQueries = React.useCallback(() => {
+    const val = store.get(reactQueries.queriesAtom);
+    Object.values(val).forEach(query => {
+      query.refetch();
+    });
+  }, [store]);
+  return jsxRuntime.jsxs(PageContainerComponent, Object.assign({
+    id: id
+  }, pageContainerProps, {
+    children: [jsxRuntime.jsx(MetadataManager, {
+      meta: meta,
+      ns: ns,
+      pageId: id
+    }), jsxRuntime.jsx(HeaderContainer, Object.assign({
+      allContents: allContents,
+      handleRefresh: refreshQueries
+    }, mappedViewSettings.header, {
+      pageId: id,
+      children: header
+    })), jsxRuntime.jsx(LayoutComponent, Object.assign({
+      allContents: allContents,
+      handleRefresh: refreshQueries,
+      viewSettings: mappedViewSettings,
+      pageId: id
+    }, layoutProps, {
+      children: layoutBody
+    }), id), jsxRuntime.jsx(FooterContainer, Object.assign({
+      allContents: allContents,
+      handleRefresh: refreshQueries
+    }, mappedViewSettings.footer, {
+      pageId: id,
+      children: footer
+    }))]
+  }), id);
+};const ContainerImpl = t0 => {
+  const $ = compilerRuntime.c(13);
+  const {
+    content,
+    ns,
+    pageId
+  } = t0;
+  const {
+    ItemsContainer
+  } = usePageConfigValue();
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      elements: [],
+      formContents: [],
+      errors: [],
+      formValues: {},
+      setValue: _temp
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  let t2;
+  if ($[1] !== content.items || $[2] !== ns || $[3] !== pageId) {
+    t2 = {
+      pageId,
+      contents: content.items,
+      ns,
+      formData: t1
+    };
+    $[1] = content.items;
+    $[2] = ns;
+    $[3] = pageId;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const {
+    components
+  } = useGenerateContentRender(t2);
+  const CustomContainer = content.component;
+  let t3;
+  if ($[5] !== components) {
+    t3 = components.map(_temp2);
+    $[5] = components;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const children = t3;
+  if (!CustomContainer) {
+    let t4;
+    if ($[7] !== ItemsContainer || $[8] !== children) {
+      t4 = jsxRuntime.jsx(ItemsContainer, {
+        children
+      });
+      $[7] = ItemsContainer;
+      $[8] = children;
+      $[9] = t4;
+    } else {
+      t4 = $[9];
+    }
+    return t4;
+  }
+  let t4;
+  if ($[10] !== CustomContainer || $[11] !== children) {
+    t4 = jsxRuntime.jsx(CustomContainer, {
+      children
+    });
+    $[10] = CustomContainer;
+    $[11] = children;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  return t4;
+};
+// Export with React.memo and fast-deep-equal comparator for optimal performance
+const Container = React.memo(ContainerImpl, (prevProps, nextProps) => {
+  // Return true if props are equal (component should NOT re-render)
+  return deepEqual(prevProps, nextProps);
+});
+function _temp() {}
+function _temp2(el) {
+  return el.element;
+}const ComponentFunctionMap = t0 => {
+  const $ = compilerRuntime.c(6);
+  const {
+    Component,
+    pageId
+  } = t0;
+  let t1;
+  if ($[0] !== pageId) {
+    t1 = {
+      pageId
+    };
+    $[0] = pageId;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const {
+    get,
+    set
+  } = usePageValues(t1);
+  let t2;
+  if ($[2] !== Component || $[3] !== get || $[4] !== set) {
+    t2 = jsxRuntime.jsx(Component, {
+      get,
+      set
+    });
+    $[2] = Component;
+    $[3] = get;
+    $[4] = set;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+};
+// Internal component implementation
+const RenderComponentImpl = ({
+  content,
+  pageId
+}) => {
+  const {
+    component: Component
+  } = content;
+  if (typeof Component === 'function') {
+    return jsxRuntime.jsx(ComponentFunctionMap, {
+      Component: Component,
+      pageId: pageId
+    });
+  } else {
+    return Component;
+  }
+};
+// Export with React.memo and fast-deep-equal comparator for optimal performance
+const RenderComponent = React.memo(RenderComponentImpl, (prevProps, nextProps) => {
+  // Return true if props are equal (component should NOT re-render)
+  return deepEqual(prevProps, nextProps);
+});const RenderComponents = props => {
+  if (props.content.type === 'container') {
+    return jsxRuntime.jsx(Container, {
+      content: props.content,
+      ns: props.ns,
+      pageId: props.pageId
+    }, props.key);
+  }
+  return jsxRuntime.jsx(RenderComponent, {
+    content: props.content,
+    ns: props.ns,
+    pageId: props.pageId
+  }, props.key);
+};/**
+ * Next.js Integration Helpers
+ *
+ * Provides helpers for using the pages metadata system with Next.js:
+ * - `toNextMetadata()` — App Router (`generateMetadata`)
+ * - `NextHeadFromMetadata` — Pages Router (`next/head`)
+ *
+ * @module integrations/next
+ */
+// ─── toNextMetadata (App Router) ─────────────────────────────
+/**
+ * Convert ResolvedMetadata into a Next.js Metadata object
+ * for use with App Router's `generateMetadata` or `metadata` export.
+ *
+ * @example
+ * ```ts
+ * // app/page.tsx
+ * import { resolveMetadata, toNextMetadata } from '@/core/pages';
+ *
+ * export async function generateMetadata() {
+ *   const resolved = resolveMetadata(pageConfig.meta, context);
+ *   return toNextMetadata(resolved);
+ * }
+ * ```
+ */
+function toNextMetadata(resolved) {
+  var _a, _b, _c, _d, _e, _f;
+  const result = {};
+  // Basic
+  if (resolved.title) result.title = resolved.title;
+  if (resolved.description) result.description = resolved.description;
+  if ((_a = resolved.keywords) === null || _a === void 0 ? void 0 : _a.length) result.keywords = resolved.keywords;
+  if (resolved.author) result.authors = [{
+    name: resolved.author
+  }];
+  if (resolved.viewport) result.viewport = resolved.viewport;
+  if (resolved.themeColor) result.themeColor = resolved.themeColor;
+  // Robots
+  if (resolved.robots || resolved.disableIndexing) {
+    const r = (_b = resolved.robots) !== null && _b !== void 0 ? _b : {};
+    result.robots = {
+      index: !(resolved.disableIndexing || r.noindex),
+      follow: !(resolved.disableIndexing || r.nofollow),
+      noarchive: r.noarchive,
+      nosnippet: r.nosnippet,
+      'max-image-preview': r.maxImagePreview,
+      'max-snippet': r.maxSnippet
+    };
+  }
+  // Alternates
+  if (resolved.canonical || resolved.alternates) {
+    result.alternates = {
+      canonical: (_d = (_c = resolved.alternates) === null || _c === void 0 ? void 0 : _c.canonical) !== null && _d !== void 0 ? _d : resolved.canonical,
+      languages: (_e = resolved.alternates) === null || _e === void 0 ? void 0 : _e.languages,
+      media: (_f = resolved.alternates) === null || _f === void 0 ? void 0 : _f.media
+    };
+  }
+  // Open Graph
+  if (resolved.openGraph) {
+    const og = resolved.openGraph;
+    const nextOg = {};
+    if (og.title) nextOg.title = og.title;
+    if (og.description) nextOg.description = og.description;
+    if (og.url) nextOg.url = og.url;
+    if (og.siteName) nextOg.siteName = og.siteName;
+    if (og.locale) nextOg.locale = og.locale;
+    if (og.type) nextOg.type = og.type;
+    // Images
+    const images = normalizeOgImages(og.images, og.image);
+    if (images.length) {
+      nextOg.images = images.map(img => ({
+        url: img.url,
+        alt: img.alt,
+        width: img.width,
+        height: img.height,
+        type: img.type
+      }));
+    }
+    // Article metadata
+    if (og.article) {
+      if (og.article.publishedTime) nextOg.publishedTime = og.article.publishedTime;
+      if (og.article.modifiedTime) nextOg.modifiedTime = og.article.modifiedTime;
+      if (og.article.section) nextOg.section = og.article.section;
+      if (og.article.tags) nextOg.tags = og.article.tags;
+      if (og.article.author) {
+        nextOg.authors = Array.isArray(og.article.author) ? og.article.author : [og.article.author];
+      }
+    }
+    result.openGraph = nextOg;
+  }
+  // Twitter
+  if (resolved.twitter) {
+    const tw = resolved.twitter;
+    const nextTw = {};
+    if (tw.card) nextTw.card = tw.card;
+    if (tw.site) nextTw.site = tw.site;
+    if (tw.creator) nextTw.creator = tw.creator;
+    if (tw.title) nextTw.title = tw.title;
+    if (tw.description) nextTw.description = tw.description;
+    if (tw.image) {
+      nextTw.images = tw.imageAlt ? [{
+        url: tw.image,
+        alt: tw.imageAlt
+      }] : [tw.image];
+    }
+    result.twitter = nextTw;
+  }
+  // Icons
+  if (resolved.icons) {
+    const icons = resolved.icons;
+    const nextIcons = {};
+    if (icons.icon) {
+      const list = typeof icons.icon === 'string' ? [{
+        url: icons.icon
+      }] : Array.isArray(icons.icon) ? icons.icon : [icons.icon];
+      nextIcons.icon = list.map(i => ({
+        url: i.url,
+        type: i.type,
+        sizes: i.sizes
+      }));
+    }
+    if (icons.apple) {
+      const list = typeof icons.apple === 'string' ? [{
+        url: icons.apple
+      }] : Array.isArray(icons.apple) ? icons.apple : [icons.apple];
+      nextIcons.apple = list.map(i => ({
+        url: i.url,
+        type: i.type,
+        sizes: i.sizes
+      }));
+    }
+    if (icons.shortcut) nextIcons.shortcut = icons.shortcut;
+    result.icons = nextIcons;
+  }
+  // Manifest
+  if (resolved.manifest) result.manifest = resolved.manifest;
+  return result;
+}
+function toNextHeadTags(resolved) {
+  var _a, _b;
+  const tags = [];
+  if (resolved.title) {
+    tags.push({
+      key: 'title',
+      tag: 'title',
+      attributes: {},
+      content: resolved.title
+    });
+  }
+  if (resolved.description) {
+    tags.push({
+      key: 'desc',
+      tag: 'meta',
+      attributes: {
+        name: 'description',
+        content: resolved.description
+      }
+    });
+  }
+  if (resolved.canonical) {
+    tags.push({
+      key: 'canonical',
+      tag: 'link',
+      attributes: {
+        rel: 'canonical',
+        href: resolved.canonical
+      }
+    });
+  }
+  if ((_a = resolved.keywords) === null || _a === void 0 ? void 0 : _a.length) {
+    tags.push({
+      key: 'keywords',
+      tag: 'meta',
+      attributes: {
+        name: 'keywords',
+        content: resolved.keywords.join(', ')
+      }
+    });
+  }
+  if (resolved.author) {
+    tags.push({
+      key: 'author',
+      tag: 'meta',
+      attributes: {
+        name: 'author',
+        content: resolved.author
+      }
+    });
+  }
+  if (resolved.viewport) {
+    tags.push({
+      key: 'viewport',
+      tag: 'meta',
+      attributes: {
+        name: 'viewport',
+        content: resolved.viewport
+      }
+    });
+  }
+  if (resolved.themeColor) {
+    tags.push({
+      key: 'theme-color',
+      tag: 'meta',
+      attributes: {
+        name: 'theme-color',
+        content: resolved.themeColor
+      }
+    });
+  }
+  // OG
+  if (resolved.openGraph) {
+    const og = resolved.openGraph;
+    if (og.type) tags.push({
+      key: 'og:type',
+      tag: 'meta',
+      attributes: {
+        property: 'og:type',
+        content: og.type
+      }
+    });
+    if (og.title) tags.push({
+      key: 'og:title',
+      tag: 'meta',
+      attributes: {
+        property: 'og:title',
+        content: og.title
+      }
+    });
+    if (og.description) tags.push({
+      key: 'og:desc',
+      tag: 'meta',
+      attributes: {
+        property: 'og:description',
+        content: og.description
+      }
+    });
+    if (og.url) tags.push({
+      key: 'og:url',
+      tag: 'meta',
+      attributes: {
+        property: 'og:url',
+        content: og.url
+      }
+    });
+    if (og.siteName) tags.push({
+      key: 'og:site',
+      tag: 'meta',
+      attributes: {
+        property: 'og:site_name',
+        content: og.siteName
+      }
+    });
+    if (og.locale) tags.push({
+      key: 'og:locale',
+      tag: 'meta',
+      attributes: {
+        property: 'og:locale',
+        content: og.locale
+      }
+    });
+    const images = normalizeOgImages(og.images, og.image);
+    images.forEach((img, i) => {
+      tags.push({
+        key: `og:img:${i}`,
+        tag: 'meta',
+        attributes: {
+          property: 'og:image',
+          content: img.url
+        }
+      });
+      if (img.alt) tags.push({
+        key: `og:img:alt:${i}`,
+        tag: 'meta',
+        attributes: {
+          property: 'og:image:alt',
+          content: img.alt
+        }
+      });
+      if (img.width) tags.push({
+        key: `og:img:w:${i}`,
+        tag: 'meta',
+        attributes: {
+          property: 'og:image:width',
+          content: String(img.width)
+        }
+      });
+      if (img.height) tags.push({
+        key: `og:img:h:${i}`,
+        tag: 'meta',
+        attributes: {
+          property: 'og:image:height',
+          content: String(img.height)
+        }
+      });
+    });
+  }
+  // Twitter
+  if (resolved.twitter) {
+    const tw = resolved.twitter;
+    if (tw.card) tags.push({
+      key: 'tw:card',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:card',
+        content: tw.card
+      }
+    });
+    if (tw.site) tags.push({
+      key: 'tw:site',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:site',
+        content: tw.site
+      }
+    });
+    if (tw.creator) tags.push({
+      key: 'tw:creator',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:creator',
+        content: tw.creator
+      }
+    });
+    if (tw.title) tags.push({
+      key: 'tw:title',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:title',
+        content: tw.title
+      }
+    });
+    if (tw.description) tags.push({
+      key: 'tw:desc',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:description',
+        content: tw.description
+      }
+    });
+    if (tw.image) tags.push({
+      key: 'tw:img',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:image',
+        content: tw.image
+      }
+    });
+    if (tw.imageAlt) tags.push({
+      key: 'tw:img:alt',
+      tag: 'meta',
+      attributes: {
+        name: 'twitter:image:alt',
+        content: tw.imageAlt
+      }
+    });
+  }
+  // Hreflang
+  if ((_b = resolved.alternates) === null || _b === void 0 ? void 0 : _b.languages) {
+    Object.entries(resolved.alternates.languages).forEach(([locale, url]) => {
+      tags.push({
+        key: `hreflang:${locale}`,
+        tag: 'link',
+        attributes: {
+          rel: 'alternate',
+          hreflang: locale,
+          href: url
+        }
+      });
+    });
+  }
+  // Manifest
+  if (resolved.manifest) {
+    tags.push({
+      key: 'manifest',
+      tag: 'link',
+      attributes: {
+        rel: 'manifest',
+        href: resolved.manifest
+      }
+    });
+  }
+  return tags;
+}
+// ─── Helpers ─────────────────────────────────────────────────
+function normalizeOgImages(images, singleImage) {
+  if (images === null || images === void 0 ? void 0 : images.length) return images;
+  if (!singleImage) return [];
+  return [typeof singleImage === 'string' ? {
+    url: singleImage
+  } : singleImage];
+}/**
+ * Sitemap & Robots.txt Generation Helpers
+ *
+ * Provides functions for generating sitemap.xml and robots.txt content
+ * from page metadata. Useful for:
+ * - Next.js App Router `app/sitemap.ts` and `app/robots.ts`
+ * - Any SSR/SSG framework that needs sitemap generation
+ *
+ * @module integrations/sitemap
+ */
+/**
+ * Generate a sitemap.xml string from a list of entries.
+ *
+ * @example
+ * ```ts
+ * // app/sitemap.ts (Next.js App Router)
+ * import { generateSitemapXml } from '@/core/pages/integrations/sitemap';
+ *
+ * export default function sitemap() {
+ *   return generateSitemapEntries([
+ *     { url: 'https://example.com', changeFrequency: 'daily', priority: 1.0 },
+ *     { url: 'https://example.com/about', changeFrequency: 'monthly', priority: 0.8 },
+ *   ]);
+ * }
+ * ```
+ */
+function generateSitemapXml(entries) {
+  const urls = entries.map(entry => {
+    const parts = [`    <loc>${escapeXml(entry.url)}</loc>`];
+    if (entry.lastModified) {
+      const dateStr = entry.lastModified instanceof Date ? entry.lastModified.toISOString() : entry.lastModified;
+      parts.push(`    <lastmod>${escapeXml(dateStr)}</lastmod>`);
+    }
+    if (entry.changeFrequency) {
+      parts.push(`    <changefreq>${entry.changeFrequency}</changefreq>`);
+    }
+    if (entry.priority != null) {
+      parts.push(`    <priority>${entry.priority.toFixed(1)}</priority>`);
+    }
+    // xhtml:link for alternates
+    if (entry.alternates) {
+      Object.entries(entry.alternates).forEach(([lang, href]) => {
+        parts.push(`    <xhtml:link rel="alternate" hreflang="${escapeXml(lang)}" href="${escapeXml(href)}" />`);
+      });
+    }
+    return `  <url>\n${parts.join('\n')}\n  </url>`;
+  });
+  return ['<?xml version="1.0" encoding="UTF-8"?>', '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">', ...urls, '</urlset>'].join('\n');
+}
+/**
+ * Generate structured sitemap entries compatible with Next.js App Router `sitemap()`.
+ * Returns plain objects that Next.js can serialize.
+ */
+function generateSitemapEntries(entries) {
+  return entries.map(entry => ({
+    url: entry.url,
+    lastModified: entry.lastModified ? entry.lastModified instanceof Date ? entry.lastModified : new Date(entry.lastModified) : undefined,
+    changeFrequency: entry.changeFrequency,
+    priority: entry.priority
+  }));
+}
+/**
+ * Generate a robots.txt string from configuration.
+ *
+ * @example
+ * ```ts
+ * // app/robots.ts (Next.js App Router)
+ * import { generateRobotsTxt } from '@/core/pages/integrations/sitemap';
+ *
+ * export default function robots() {
+ *   return generateRobotsTxt({
+ *     rules: [
+ *       { userAgent: '*', allow: ['/'], disallow: ['/admin'] },
+ *       { userAgent: 'Googlebot', allow: ['/'] },
+ *     ],
+ *     sitemap: 'https://example.com/sitemap.xml',
+ *   });
+ * }
+ * ```
+ */
+function generateRobotsTxt(config) {
+  const lines = [];
+  config.rules.forEach(rule => {
+    var _a, _b;
+    const agents = Array.isArray(rule.userAgent) ? rule.userAgent : [rule.userAgent];
+    agents.forEach(agent => {
+      lines.push(`User-agent: ${agent}`);
+    });
+    (_a = rule.allow) === null || _a === void 0 ? void 0 : _a.forEach(path => {
+      lines.push(`Allow: ${path}`);
+    });
+    (_b = rule.disallow) === null || _b === void 0 ? void 0 : _b.forEach(path => {
+      lines.push(`Disallow: ${path}`);
+    });
+    if (rule.crawlDelay != null) {
+      lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+    }
+    lines.push('');
+  });
+  // Sitemap
+  const sitemaps = config.sitemap ? Array.isArray(config.sitemap) ? config.sitemap : [config.sitemap] : [];
+  sitemaps.forEach(url => {
+    lines.push(`Sitemap: ${url}`);
+  });
+  // Host
+  if (config.host) {
+    lines.push(`Host: ${config.host}`);
+  }
+  return lines.join('\n');
+}
+// ─── Helpers ─────────────────────────────────────────────────
+function escapeXml(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}/**
+ * JSON-LD Structured Data Builders
+ *
+ * Helpers to build valid schema.org JSON-LD objects for common types.
+ * These can be passed to MetadataConfig.structuredData.schema or used
+ * directly in a <script type="application/ld+json"> tag.
+ *
+ * @module integrations/jsonld
+ */
+function buildOrganizationJsonLd(input) {
+  var _a;
+  const schema = {
+    '@context': 'https://schema.org',
+    '@type': 'Organization',
+    name: input.name,
+    url: input.url
+  };
+  if (input.logo) schema.logo = input.logo;
+  if (input.description) schema.description = input.description;
+  if ((_a = input.sameAs) === null || _a === void 0 ? void 0 : _a.length) schema.sameAs = input.sameAs;
+  if (input.contactPoint) {
+    const cp = {
+      '@type': 'ContactPoint'
+    };
+    if (input.contactPoint.telephone) cp.telephone = input.contactPoint.telephone;
+    if (input.contactPoint.contactType) cp.contactType = input.contactPoint.contactType;
+    if (input.contactPoint.email) cp.email = input.contactPoint.email;
+    if (input.contactPoint.areaServed) cp.areaServed = input.contactPoint.areaServed;
+    if (input.contactPoint.availableLanguage) cp.availableLanguage = input.contactPoint.availableLanguage;
+    schema.contactPoint = cp;
+  }
+  return schema;
+}
+function buildWebSiteJsonLd(input) {
+  const schema = {
+    '@context': 'https://schema.org',
+    '@type': 'WebSite',
+    name: input.name,
+    url: input.url
+  };
+  if (input.description) schema.description = input.description;
+  if (input.potentialAction) {
+    schema.potentialAction = {
+      '@type': 'SearchAction',
+      target: input.potentialAction.target,
+      'query-input': input.potentialAction.queryInput
+    };
+  }
+  return schema;
+}
+function buildBreadcrumbListJsonLd(items) {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: items.map((item, index) => ({
+      '@type': 'ListItem',
+      position: index + 1,
+      name: item.name,
+      item: item.url
+    }))
+  };
+}
+function buildArticleJsonLd(input) {
+  const schema = {
+    '@context': 'https://schema.org',
+    '@type': 'Article',
+    headline: input.headline
+  };
+  if (input.description) schema.description = input.description;
+  if (input.image) {
+    schema.image = Array.isArray(input.image) ? input.image : [input.image];
+  }
+  if (input.datePublished) schema.datePublished = input.datePublished;
+  if (input.dateModified) schema.dateModified = input.dateModified;
+  if (input.author) {
+    const authors = Array.isArray(input.author) ? input.author : [input.author];
+    schema.author = authors.map(a => Object.assign({
+      '@type': 'Person',
+      name: a.name
+    }, a.url ? {
+      url: a.url
+    } : {}));
+  }
+  if (input.publisher) {
+    const pub = {
+      '@type': 'Organization',
+      name: input.publisher.name
+    };
+    if (input.publisher.logo) {
+      pub.logo = {
+        '@type': 'ImageObject',
+        url: input.publisher.logo
+      };
+    }
+    schema.publisher = pub;
+  }
+  if (input.url) schema.url = input.url;
+  if (input.mainEntityOfPage) {
+    schema.mainEntityOfPage = {
+      '@type': 'WebPage',
+      '@id': input.mainEntityOfPage
+    };
+  }
+  return schema;
+}
+function buildFAQPageJsonLd(items) {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: items.map(item => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: item.answer
+      }
+    }))
+  };
+}
+function buildProductJsonLd(input) {
+  const schema = {
+    '@context': 'https://schema.org',
+    '@type': 'Product',
+    name: input.name
+  };
+  if (input.description) schema.description = input.description;
+  if (input.image) {
+    schema.image = Array.isArray(input.image) ? input.image : [input.image];
+  }
+  if (input.brand) {
+    schema.brand = {
+      '@type': 'Brand',
+      name: input.brand
+    };
+  }
+  if (input.sku) schema.sku = input.sku;
+  if (input.offers) {
+    const offer = {
+      '@type': 'Offer',
+      price: input.offers.price,
+      priceCurrency: input.offers.priceCurrency
+    };
+    if (input.offers.availability) {
+      offer.availability = `https://schema.org/${input.offers.availability}`;
+    }
+    if (input.offers.url) offer.url = input.offers.url;
+    if (input.offers.priceValidUntil) offer.priceValidUntil = input.offers.priceValidUntil;
+    schema.offers = offer;
+  }
+  if (input.aggregateRating) {
+    const rating = {
+      '@type': 'AggregateRating',
+      ratingValue: input.aggregateRating.ratingValue,
+      reviewCount: input.aggregateRating.reviewCount
+    };
+    if (input.aggregateRating.bestRating != null) rating.bestRating = input.aggregateRating.bestRating;
+    if (input.aggregateRating.worstRating != null) rating.worstRating = input.aggregateRating.worstRating;
+    schema.aggregateRating = rating;
+  }
+  return schema;
+}/**
+ * LLMs.txt Generation Support
+ *
+ * Generates `llms.txt` and `llms-full.txt` content following the
+ * llms.txt specification (https://llmstxt.org/).
+ *
+ * The llms.txt file helps LLMs and AI agents discover what a site offers
+ * and where to find key documentation/content.
+ *
+ * @module integrations/llms
+ */
+/**
+ * Generate llms.txt content from configuration.
+ *
+ * Format (per spec):
+ * ```
+ * # Site Name
+ *
+ * > Brief description of the site
+ *
+ * ## Docs
+ *
+ * - [Title](url): Description
+ * - [Title](url): Description
+ * ```
+ *
+ * @example
+ * ```ts
+ * const content = generateLlmsTxt({
+ *   siteName: 'My App',
+ *   siteDescription: 'A great application for doing things.',
+ *   entries: [
+ *     { url: '/docs/getting-started', title: 'Getting Started', description: 'How to set up My App' },
+ *     { url: '/docs/api', title: 'API Reference', description: 'Complete API documentation' },
+ *   ],
+ * });
+ * // Write `content` to /llms.txt
+ * ```
+ */
+function generateLlmsTxt(config) {
+  const lines = [];
+  // Header
+  lines.push(`# ${config.siteName}`);
+  lines.push('');
+  // Description
+  if (config.siteDescription) {
+    lines.push(`> ${config.siteDescription}`);
+    lines.push('');
+  }
+  // Entries grouped under "Docs"
+  if (config.entries.length > 0) {
+    lines.push('## Docs');
+    lines.push('');
+    config.entries.forEach(entry => {
+      const desc = entry.description ? `: ${entry.description}` : '';
+      lines.push(`- [${entry.title}](${entry.url})${desc}`);
+    });
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+/**
+ * Generate a full markdown version (llms-full.txt) that includes
+ * more detailed content for each entry.
+ *
+ * This is useful for providing LLMs with the complete documentation
+ * in a single file.
+ */
+function generateLlmsFullTxt(config, pageContents) {
+  const lines = [];
+  lines.push(`# ${config.siteName}`);
+  lines.push('');
+  if (config.siteDescription) {
+    lines.push(`> ${config.siteDescription}`);
+    lines.push('');
+  }
+  pageContents.forEach(({
+    entry,
+    markdown
+  }) => {
+    lines.push(`## ${entry.title}`);
+    lines.push('');
+    if (entry.description) {
+      lines.push(`> ${entry.description}`);
+      lines.push('');
+    }
+    lines.push(`Source: ${entry.url}`);
+    lines.push('');
+    lines.push(markdown);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  });
+  return lines.join('\n');
+}
+/**
+ * Helper to convert a ResolvedMetadata + page text into a clean markdown
+ * representation suitable for llms-full.txt or standalone .md endpoints.
+ *
+ * Strips HTML chrome, keeps headings coherent, and prepends metadata summary.
+ */
+function pageToMarkdown(options) {
+  const lines = [];
+  lines.push(`# ${options.title}`);
+  lines.push('');
+  if (options.description) {
+    lines.push(options.description);
+    lines.push('');
+  }
+  lines.push(`URL: ${options.url}`);
+  lines.push('');
+  lines.push(options.content);
+  return lines.join('\n');
+}exports.MemoizationCache=MemoizationCache;exports.MetadataStoreProvider=MetadataStoreProvider;exports.PageGenerator=PageGenerator;exports.RenderComponents=RenderComponents;exports.applyMetadataToDom=applyMetadataToDom;exports.buildArticleJsonLd=buildArticleJsonLd;exports.buildBreadcrumbListJsonLd=buildBreadcrumbListJsonLd;exports.buildFAQPageJsonLd=buildFAQPageJsonLd;exports.buildOrganizationJsonLd=buildOrganizationJsonLd;exports.buildProductJsonLd=buildProductJsonLd;exports.buildWebSiteJsonLd=buildWebSiteJsonLd;exports.clearMetadataLog=clearMetadataLog;exports.collectMetadataToHtml=collectMetadataToHtml;exports.createMetadataStore=createMetadataStore;exports.createScopePageVariablesAtom=createScopePageVariablesAtom;exports.deepEqual=deepEqual;exports.generateLlmsFullTxt=generateLlmsFullTxt;exports.generateLlmsTxt=generateLlmsTxt;exports.generateRobotsTxt=generateRobotsTxt;exports.generateSitemapEntries=generateSitemapEntries;exports.generateSitemapXml=generateSitemapXml;exports.getMetadata=getMetadata;exports.getMetadataLog=getMetadataLog;exports.getPageConfig=getPageConfig;exports.getPageVariablesCompositeKey=getPageVariablesCompositeKey;exports.isStableValue=isStableValue;exports.logMetadata=logMetadata;exports.memoPropsComparator=memoPropsComparator;exports.memoize=memoize;exports.optimizeDeps=optimizeDeps;exports.pageConfigAtom=pageConfigAtom;exports.pageToMarkdown=pageToMarkdown;exports.pageVariablesAtom=pageVariablesAtom;exports.pageVariablesAtomFamily=pageVariablesAtomFamily;exports.resetMetadata=resetMetadata;exports.resolveMetadata=resolveMetadata;exports.setMetadata=setMetadata;exports.setMetadataLogging=setMetadataLogging;exports.shallowEqual=shallowEqual;exports.toNextHeadTags=toNextHeadTags;exports.toNextMetadata=toNextMetadata;exports.useApplyMetadata=useApplyMetadata;exports.useFormData=useFormData;exports.useGenerateContent=useGenerateContent;exports.useGenerateContentRender=useGenerateContentRender;exports.useMetadata=useMetadata;exports.useMetadataStore=useMetadataStore;exports.usePageConfig=usePageConfig;exports.usePageConfigReset=usePageConfigReset;exports.usePageConfigState=usePageConfigState;exports.usePageConfigValue=usePageConfigValue;exports.useViewSettings=useViewSettings;//# sourceMappingURL=index.js.map