@uniweb/runtime 0.8.41 → 0.9.0

package/dist/worker-runtime.js

@@ -1012,275 +1012,6 @@ var require_react = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js
-var require_react_jsx_runtime_development = __commonJS({
-  "../../node_modules/.pnpm/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
-    "use strict";
-    (function() {
-      function getComponentNameFromType(type) {
-        if (null == type) return null;
-        if ("function" === typeof type)
-          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
-        if ("string" === typeof type) return type;
-        switch (type) {
-          case REACT_FRAGMENT_TYPE:
-            return "Fragment";
-          case REACT_PROFILER_TYPE:
-            return "Profiler";
-          case REACT_STRICT_MODE_TYPE:
-            return "StrictMode";
-          case REACT_SUSPENSE_TYPE:
-            return "Suspense";
-          case REACT_SUSPENSE_LIST_TYPE:
-            return "SuspenseList";
-          case REACT_ACTIVITY_TYPE:
-            return "Activity";
-        }
-        if ("object" === typeof type)
-          switch ("number" === typeof type.tag && console.error(
-            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-          ), type.$$typeof) {
-            case REACT_PORTAL_TYPE:
-              return "Portal";
-            case REACT_CONTEXT_TYPE:
-              return type.displayName || "Context";
-            case REACT_CONSUMER_TYPE:
-              return (type._context.displayName || "Context") + ".Consumer";
-            case REACT_FORWARD_REF_TYPE:
-              var innerType = type.render;
-              type = type.displayName;
-              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
-              return type;
-            case REACT_MEMO_TYPE:
-              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
-            case REACT_LAZY_TYPE:
-              innerType = type._payload;
-              type = type._init;
-              try {
-                return getComponentNameFromType(type(innerType));
-              } catch (x) {
-              }
-          }
-        return null;
-      }
-      function testStringCoercion(value) {
-        return "" + value;
-      }
-      function checkKeyStringCoercion(value) {
-        try {
-          testStringCoercion(value);
-          var JSCompiler_inline_result = false;
-        } catch (e) {
-          JSCompiler_inline_result = true;
-        }
-        if (JSCompiler_inline_result) {
-          JSCompiler_inline_result = console;
-          var JSCompiler_temp_const = JSCompiler_inline_result.error;
-          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
-          JSCompiler_temp_const.call(
-            JSCompiler_inline_result,
-            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-            JSCompiler_inline_result$jscomp$0
-          );
-          return testStringCoercion(value);
-        }
-      }
-      function getTaskName(type) {
-        if (type === REACT_FRAGMENT_TYPE) return "<>";
-        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
-          return "<...>";
-        try {
-          var name = getComponentNameFromType(type);
-          return name ? "<" + name + ">" : "<...>";
-        } catch (x) {
-          return "<...>";
-        }
-      }
-      function getOwner() {
-        var dispatcher = ReactSharedInternals.A;
-        return null === dispatcher ? null : dispatcher.getOwner();
-      }
-      function UnknownOwner() {
-        return Error("react-stack-top-frame");
-      }
-      function hasValidKey(config) {
-        if (hasOwnProperty.call(config, "key")) {
-          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
-          if (getter && getter.isReactWarning) return false;
-        }
-        return void 0 !== config.key;
-      }
-      function defineKeyPropWarningGetter(props, displayName) {
-        function warnAboutAccessingKey() {
-          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
-            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-            displayName
-          ));
-        }
-        warnAboutAccessingKey.isReactWarning = true;
-        Object.defineProperty(props, "key", {
-          get: warnAboutAccessingKey,
-          configurable: true
-        });
-      }
-      function elementRefGetterWithDeprecationWarning() {
-        var componentName = getComponentNameFromType(this.type);
-        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
-          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-        ));
-        componentName = this.props.ref;
-        return void 0 !== componentName ? componentName : null;
-      }
-      function ReactElement(type, key, props, owner, debugStack, debugTask) {
-        var refProp = props.ref;
-        type = {
-          $$typeof: REACT_ELEMENT_TYPE,
-          type,
-          key,
-          props,
-          _owner: owner
-        };
-        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
-          enumerable: false,
-          get: elementRefGetterWithDeprecationWarning
-        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
-        type._store = {};
-        Object.defineProperty(type._store, "validated", {
-          configurable: false,
-          enumerable: false,
-          writable: true,
-          value: 0
-        });
-        Object.defineProperty(type, "_debugInfo", {
-          configurable: false,
-          enumerable: false,
-          writable: true,
-          value: null
-        });
-        Object.defineProperty(type, "_debugStack", {
-          configurable: false,
-          enumerable: false,
-          writable: true,
-          value: debugStack
-        });
-        Object.defineProperty(type, "_debugTask", {
-          configurable: false,
-          enumerable: false,
-          writable: true,
-          value: debugTask
-        });
-        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
-        return type;
-      }
-      function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
-        var children = config.children;
-        if (void 0 !== children)
-          if (isStaticChildren)
-            if (isArrayImpl(children)) {
-              for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
-                validateChildKeys(children[isStaticChildren]);
-              Object.freeze && Object.freeze(children);
-            } else
-              console.error(
-                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
-              );
-          else validateChildKeys(children);
-        if (hasOwnProperty.call(config, "key")) {
-          children = getComponentNameFromType(type);
-          var keys = Object.keys(config).filter(function(k) {
-            return "key" !== k;
-          });
-          isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
-          didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
-            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
-            isStaticChildren,
-            children,
-            keys,
-            children
-          ), didWarnAboutKeySpread[children + isStaticChildren] = true);
-        }
-        children = null;
-        void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
-        hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
-        if ("key" in config) {
-          maybeKey = {};
-          for (var propName in config)
-            "key" !== propName && (maybeKey[propName] = config[propName]);
-        } else maybeKey = config;
-        children && defineKeyPropWarningGetter(
-          maybeKey,
-          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
-        );
-        return ReactElement(
-          type,
-          children,
-          maybeKey,
-          getOwner(),
-          debugStack,
-          debugTask
-        );
-      }
-      function validateChildKeys(node) {
-        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
-      }
-      function isValidElement(object) {
-        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
-      }
-      var React2 = require_react(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = React2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
-        return null;
-      };
-      React2 = {
-        react_stack_bottom_frame: function(callStackForError) {
-          return callStackForError();
-        }
-      };
-      var specialPropKeyWarningShown;
-      var didWarnAboutElementRef = {};
-      var unknownOwnerDebugStack = React2.react_stack_bottom_frame.bind(
-        React2,
-        UnknownOwner
-      )();
-      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
-      var didWarnAboutKeySpread = {};
-      exports.Fragment = REACT_FRAGMENT_TYPE;
-      exports.jsx = function(type, config, maybeKey) {
-        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-        return jsxDEVImpl(
-          type,
-          config,
-          maybeKey,
-          false,
-          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
-          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-        );
-      };
-      exports.jsxs = function(type, config, maybeKey) {
-        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-        return jsxDEVImpl(
-          type,
-          config,
-          maybeKey,
-          true,
-          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
-          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
-        );
-      };
-    })();
-  }
-});
-
-// ../../node_modules/.pnpm/react@19.2.5/node_modules/react/jsx-runtime.js
-var require_jsx_runtime = __commonJS({
-  "../../node_modules/.pnpm/react@19.2.5/node_modules/react/jsx-runtime.js"(exports, module) {
-    "use strict";
-    if (false) {
-      module.exports = null;
-    } else {
-      module.exports = require_react_jsx_runtime_development();
-    }
-  }
-});
-
 // ../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/cjs/react-dom.development.js
 var require_react_dom_development = __commonJS({
   "../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/cjs/react-dom.development.js"(exports) {
@@ -1489,51 +1220,320 @@ var require_react_dom_development = __commonJS({
             media: "string" === typeof options.media ? options.media : void 0
           });
         }
-      };
-      exports.preloadModule = function(href, options) {
-        var encountered = "";
-        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
-        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
-        encountered && console.error(
-          'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
-          encountered
+      };
+      exports.preloadModule = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+        encountered && console.error(
+          'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
+          encountered
+        );
+        "string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
+          options.as,
+          options.crossOrigin
+        ), Internals.d.m(href, {
+          as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
+          crossOrigin: encountered,
+          integrity: "string" === typeof options.integrity ? options.integrity : void 0
+        })) : Internals.d.m(href));
+      };
+      exports.requestFormReset = function(form) {
+        Internals.d.r(form);
+      };
+      exports.unstable_batchedUpdates = function(fn, a) {
+        return fn(a);
+      };
+      exports.useFormState = function(action, initialState, permalink) {
+        return resolveDispatcher().useFormState(action, initialState, permalink);
+      };
+      exports.useFormStatus = function() {
+        return resolveDispatcher().useHostTransitionStatus();
+      };
+      exports.version = "19.2.5";
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/index.js
+var require_react_dom = __commonJS({
+  "../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      checkDCE();
+      module.exports = null;
+    } else {
+      module.exports = require_react_dom_development();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = __commonJS({
+  "../../node_modules/.pnpm/react@19.2.5/node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
+    "use strict";
+    (function() {
+      function getComponentNameFromType(type) {
+        if (null == type) return null;
+        if ("function" === typeof type)
+          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+        if ("string" === typeof type) return type;
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+          case REACT_ACTIVITY_TYPE:
+            return "Activity";
+        }
+        if ("object" === typeof type)
+          switch ("number" === typeof type.tag && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), type.$$typeof) {
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case REACT_CONTEXT_TYPE:
+              return type.displayName || "Context";
+            case REACT_CONSUMER_TYPE:
+              return (type._context.displayName || "Context") + ".Consumer";
+            case REACT_FORWARD_REF_TYPE:
+              var innerType = type.render;
+              type = type.displayName;
+              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+              return type;
+            case REACT_MEMO_TYPE:
+              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE:
+              innerType = type._payload;
+              type = type._init;
+              try {
+                return getComponentNameFromType(type(innerType));
+              } catch (x) {
+              }
+          }
+        return null;
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        try {
+          testStringCoercion(value);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        if (JSCompiler_inline_result) {
+          JSCompiler_inline_result = console;
+          var JSCompiler_temp_const = JSCompiler_inline_result.error;
+          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          JSCompiler_temp_const.call(
+            JSCompiler_inline_result,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            JSCompiler_inline_result$jscomp$0
+          );
+          return testStringCoercion(value);
+        }
+      }
+      function getTaskName(type) {
+        if (type === REACT_FRAGMENT_TYPE) return "<>";
+        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+          return "<...>";
+        try {
+          var name = getComponentNameFromType(type);
+          return name ? "<" + name + ">" : "<...>";
+        } catch (x) {
+          return "<...>";
+        }
+      }
+      function getOwner() {
+        var dispatcher = ReactSharedInternals.A;
+        return null === dispatcher ? null : dispatcher.getOwner();
+      }
+      function UnknownOwner() {
+        return Error("react-stack-top-frame");
+      }
+      function hasValidKey(config) {
+        if (hasOwnProperty.call(config, "key")) {
+          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+          if (getter && getter.isReactWarning) return false;
+        }
+        return void 0 !== config.key;
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        function warnAboutAccessingKey() {
+          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            displayName
+          ));
+        }
+        warnAboutAccessingKey.isReactWarning = true;
+        Object.defineProperty(props, "key", {
+          get: warnAboutAccessingKey,
+          configurable: true
+        });
+      }
+      function elementRefGetterWithDeprecationWarning() {
+        var componentName = getComponentNameFromType(this.type);
+        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        ));
+        componentName = this.props.ref;
+        return void 0 !== componentName ? componentName : null;
+      }
+      function ReactElement(type, key, props, owner, debugStack, debugTask) {
+        var refProp = props.ref;
+        type = {
+          $$typeof: REACT_ELEMENT_TYPE,
+          type,
+          key,
+          props,
+          _owner: owner
+        };
+        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+          enumerable: false,
+          get: elementRefGetterWithDeprecationWarning
+        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+        type._store = {};
+        Object.defineProperty(type._store, "validated", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: 0
+        });
+        Object.defineProperty(type, "_debugInfo", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: null
+        });
+        Object.defineProperty(type, "_debugStack", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugStack
+        });
+        Object.defineProperty(type, "_debugTask", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugTask
+        });
+        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+        return type;
+      }
+      function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+        var children = config.children;
+        if (void 0 !== children)
+          if (isStaticChildren)
+            if (isArrayImpl(children)) {
+              for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+                validateChildKeys(children[isStaticChildren]);
+              Object.freeze && Object.freeze(children);
+            } else
+              console.error(
+                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+              );
+          else validateChildKeys(children);
+        if (hasOwnProperty.call(config, "key")) {
+          children = getComponentNameFromType(type);
+          var keys = Object.keys(config).filter(function(k) {
+            return "key" !== k;
+          });
+          isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+          didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+            isStaticChildren,
+            children,
+            keys,
+            children
+          ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+        }
+        children = null;
+        void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+        if ("key" in config) {
+          maybeKey = {};
+          for (var propName in config)
+            "key" !== propName && (maybeKey[propName] = config[propName]);
+        } else maybeKey = config;
+        children && defineKeyPropWarningGetter(
+          maybeKey,
+          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
         );
-        "string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
-          options.as,
-          options.crossOrigin
-        ), Internals.d.m(href, {
-          as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
-          crossOrigin: encountered,
-          integrity: "string" === typeof options.integrity ? options.integrity : void 0
-        })) : Internals.d.m(href));
-      };
-      exports.requestFormReset = function(form) {
-        Internals.d.r(form);
+        return ReactElement(
+          type,
+          children,
+          maybeKey,
+          getOwner(),
+          debugStack,
+          debugTask
+        );
+      }
+      function validateChildKeys(node) {
+        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+      }
+      function isValidElement(object) {
+        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      var React2 = require_react(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = React2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+        return null;
       };
-      exports.unstable_batchedUpdates = function(fn, a) {
-        return fn(a);
+      React2 = {
+        react_stack_bottom_frame: function(callStackForError) {
+          return callStackForError();
+        }
       };
-      exports.useFormState = function(action, initialState, permalink) {
-        return resolveDispatcher().useFormState(action, initialState, permalink);
+      var specialPropKeyWarningShown;
+      var didWarnAboutElementRef = {};
+      var unknownOwnerDebugStack = React2.react_stack_bottom_frame.bind(
+        React2,
+        UnknownOwner
+      )();
+      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+      var didWarnAboutKeySpread = {};
+      exports.Fragment = REACT_FRAGMENT_TYPE;
+      exports.jsx = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          false,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
       };
-      exports.useFormStatus = function() {
-        return resolveDispatcher().useHostTransitionStatus();
+      exports.jsxs = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          true,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
       };
-      exports.version = "19.2.5";
-      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
     })();
   }
 });
 
-// ../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/index.js
-var require_react_dom = __commonJS({
-  "../../node_modules/.pnpm/react-dom@19.2.5_react@19.2.5/node_modules/react-dom/index.js"(exports, module) {
+// ../../node_modules/.pnpm/react@19.2.5/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS({
+  "../../node_modules/.pnpm/react@19.2.5/node_modules/react/jsx-runtime.js"(exports, module) {
     "use strict";
     if (false) {
-      checkDCE();
       module.exports = null;
     } else {
-      module.exports = require_react_dom_development();
+      module.exports = require_react_jsx_runtime_development();
     }
   }
 });
@@ -16354,8 +16354,9 @@ var require_server_browser = __commonJS({
 });
 
 // dist/worker-runtime-entry.js
-var __PlatformReact = __toESM(require_react(), 1);
-var __PlatformJsxRuntime = __toESM(require_jsx_runtime(), 1);
+var __P0 = __toESM(require_react(), 1);
+var __P1 = __toESM(require_react_dom(), 1);
+var __P2 = __toESM(require_jsx_runtime(), 1);
 
 // ../core/src/index.js
 var src_exports = {};
@@ -16373,11 +16374,17 @@ __export(src_exports, {
   deriveCacheKey: () => deriveCacheKey,
   evaluateWhere: () => evaluate,
   getUniweb: () => getUniweb,
+  hasDarkScheme: () => hasDarkScheme,
   isRichSchema: () => isRichSchema,
+  isWildcardLanguages: () => isWildcardLanguages,
   listRequestStyleNames: () => listStyleNames,
   matchWhere: () => match,
+  normalizeLanguageList: () => normalizeLanguageList,
+  resolveDefaultLocale: () => resolveDefaultLocale,
+  resolvePublishableLocales: () => resolvePublishableLocales,
   resolveRequestStyle: () => resolveStyle,
-  substitutePlaceholders: () => substitutePlaceholders
+  substitutePlaceholders: () => substitutePlaceholders,
+  validateLanguageConfig: () => validateLanguageConfig
 });
 
 // ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/nodes/identity.js
@@ -22716,6 +22723,15 @@ function createSequenceElement(node, options = {}) {
         }),
         attrs
       };
+    case "inset_block": {
+      const { component, ...params } = attrs || {};
+      return {
+        type: "inset_block",
+        component,
+        params,
+        children: processSequence({ content })
+      };
+    }
     case "dataBlock":
       return {
         type: "dataBlock",
@@ -22839,10 +22855,64 @@ function createSequenceElement(node, options = {}) {
       };
   }
 }
+var FILE_LINK_EXTENSIONS = [
+  "pdf",
+  "doc",
+  "docx",
+  "xls",
+  "xlsx",
+  "ppt",
+  "pptx",
+  "jpg",
+  "jpeg",
+  "png",
+  "webp",
+  "gif",
+  "svg",
+  "mp4",
+  "mp3",
+  "wav",
+  "mov",
+  "zip"
+];
+function getLinkMark(node) {
+  return (node?.marks || []).find((mark) => mark.type === "link") || null;
+}
+function sameLink(a, b) {
+  if (!a || !b) return false;
+  return JSON.stringify(a.attrs || {}) === JSON.stringify(b.attrs || {});
+}
+function wrapLink(inner, linkMark) {
+  const href = linkMark.attrs.href;
+  const target = linkMark.attrs.target || "_self";
+  const extension = href.split(".").pop()?.toLowerCase();
+  const isFileLink = FILE_LINK_EXTENSIONS.includes(extension);
+  return `<a href="${href}" target="${target}"${isFileLink ? " download" : ""}>${inner}</a>`;
+}
 function getTextContent(content, options = {}) {
   if (!content) return "";
-  return content.reduce((prev, curr) => {
-    const { type, marks = [], text } = curr;
+  const groups = [];
+  for (const node of content) {
+    const link = node?.type === "text" ? getLinkMark(node) : null;
+    const last = groups[groups.length - 1];
+    if (link && last?.link && sameLink(last.link, link)) {
+      last.nodes.push(node);
+    } else {
+      groups.push({ link, nodes: [node] });
+    }
+  }
+  return groups.reduce((prev, group) => {
+    const inner = group.nodes.reduce(
+      (acc, node) => acc + renderInlineNode(node),
+      ""
+    );
+    if (!inner && !group.link) return prev;
+    return prev + (group.link ? wrapLink(inner, group.link) : inner);
+  }, "").trim();
+}
+function renderInlineNode(curr) {
+  return [curr].reduce((prev, curr2) => {
+    const { type, marks = [], text } = curr2;
     if (type === "text") {
       let styledText = text || "";
       if (marks.some((mark) => mark.type === "textStyle")) {
@@ -22879,47 +22949,22 @@ function getTextContent(content, options = {}) {
         const attrString = attrParts.length > 0 ? ` ${attrParts.join(" ")}` : "";
         styledText = `<span${attrString}>${styledText}</span>`;
       }
+      if (marks.some((mark) => mark.type === "code")) {
+        styledText = `<code>${styledText}</code>`;
+      }
       if (marks.some((mark) => mark.type === "bold")) {
         styledText = `<strong>${styledText}</strong>`;
       }
       if (marks.some((mark) => mark.type === "italic")) {
         styledText = `<em>${styledText}</em>`;
       }
-      if (marks.some((mark) => mark.type === "link")) {
-        const linkMark = marks.find((mark) => mark.type === "link");
-        const href = linkMark.attrs.href;
-        const target = linkMark.attrs.target || "_self";
-        const fileExtensions = [
-          "pdf",
-          "doc",
-          "docx",
-          "xls",
-          "xlsx",
-          "ppt",
-          "pptx",
-          "jpg",
-          "jpeg",
-          "png",
-          "webp",
-          "gif",
-          "svg",
-          "mp4",
-          "mp3",
-          "wav",
-          "mov",
-          "zip"
-        ];
-        const extension = href.split(".").pop()?.toLowerCase();
-        const isFileLink = fileExtensions.includes(extension);
-        styledText = `<a href="${href}" target="${target}"${isFileLink ? " download" : ""}>${styledText}</a>`;
-      }
       return prev + styledText;
     } else if (type === "math_inline") {
-      const latex = escapeAttr(curr.attrs?.latex || "");
-      const mathml = curr.attrs?.mathml || "";
+      const latex = escapeAttr(curr2.attrs?.latex || "");
+      const mathml = curr2.attrs?.mathml || "";
       return prev + `<span data-type="math" data-latex="${latex}" data-display="false">${mathml}</span>`;
     } else if (type === "inset_placeholder") {
-      const refId = curr.attrs?.refId;
+      const refId = curr2.attrs?.refId;
       if (!refId) return prev;
       return prev + `<uniweb-inset data-ref-id="${refId}"></uniweb-inset>`;
     } else if (type === "hardBreak") {
@@ -22927,7 +22972,7 @@ function getTextContent(content, options = {}) {
     } else {
       return prev;
     }
-  }, "").trim();
+  }, "");
 }
 function processInlineElements(content) {
   if (!content) return [];
@@ -23021,8 +23066,15 @@ function parseUniwebIcon(itemAttrs) {
   if (preserveColors) icon.preserveColors = preserveColors;
   if (href) icon.href = href;
   if (target) icon.target = target;
-  if (library) icon.library = library;
-  if (name) icon.name = name;
+  let resolvedLibrary = library;
+  let resolvedName = name;
+  if (!resolvedLibrary && typeof name === "string" && name.includes(":")) {
+    const [family, ...rest] = name.split(":");
+    resolvedLibrary = family;
+    resolvedName = rest.join(":");
+  }
+  if (resolvedLibrary) icon.library = resolvedLibrary;
+  if (resolvedName) icon.name = resolvedName;
   return icon;
 }
 function parseIconBlock(itemAttrs) {
@@ -23925,18 +23977,489 @@ function generatePalettes(colors, options = {}) {
         continue;
       }
     }
-    if (typeof colorConfig === "object" && colorConfig !== null && colorConfig.base) {
-      const { base, ...colorOptions } = colorConfig;
-      palettes[name] = generateShades(base, { ...options, ...colorOptions });
-    } else if (typeof colorConfig === "string") {
-      palettes[name] = generateShades(colorConfig, options);
+    if (typeof colorConfig === "object" && colorConfig !== null && colorConfig.base) {
+      const { base, ...colorOptions } = colorConfig;
+      palettes[name] = generateShades(base, { ...options, ...colorOptions });
+    } else if (typeof colorConfig === "string") {
+      palettes[name] = generateShades(colorConfig, options);
+    }
+  }
+  return palettes;
+}
+function isValidColor(color) {
+  try {
+    parseColor(color);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../theming/src/css-generator.js
+var DEFAULT_CONTEXT_TOKENS = {
+  light: {
+    "section": "var(--neutral-50)",
+    "card": "var(--neutral-100)",
+    "muted": "var(--neutral-200)",
+    "body": "var(--neutral-950)",
+    "heading": "var(--neutral-900)",
+    "subtle": "var(--neutral-600)",
+    "border": "var(--neutral-200)",
+    "ring": "var(--primary-500)",
+    "link": "var(--primary-600)",
+    "link-hover": "var(--primary-700)",
+    // Shade 500 is the site's colour exactly as authored (the palette anchors
+    // the input there). `link` and `primary` sit at 600 because they carry the
+    // strict contrast burden — body-size links, and white text on a fill. An
+    // accent is decorative emphasis, usually at display size, so it keeps the
+    // brand colour unmuddied instead of paying for contrast it doesn't need.
+    "accent": "var(--accent-500)",
+    "primary": "var(--primary-600)",
+    "primary-foreground": "white",
+    "primary-hover": "var(--primary-700)",
+    "primary-border": "transparent",
+    "secondary": "white",
+    "secondary-foreground": "var(--neutral-900)",
+    "secondary-hover": "var(--neutral-100)",
+    "secondary-border": "var(--neutral-300)",
+    "success": "#16a34a",
+    "success-subtle": "#f0fdf4",
+    "warning": "#d97706",
+    "warning-subtle": "#fffbeb",
+    "error": "#dc2626",
+    "error-subtle": "#fef2f2",
+    "info": "#2563eb",
+    "info-subtle": "#eff6ff"
+  },
+  medium: {
+    "section": "var(--neutral-100)",
+    "card": "var(--neutral-200)",
+    "muted": "var(--neutral-300)",
+    "body": "var(--neutral-950)",
+    "heading": "var(--neutral-900)",
+    "subtle": "var(--neutral-700)",
+    "border": "var(--neutral-300)",
+    "ring": "var(--primary-500)",
+    "link": "var(--primary-600)",
+    "link-hover": "var(--primary-700)",
+    "accent": "var(--accent-500)",
+    // exact brand — see the light context
+    "primary": "var(--primary-600)",
+    "primary-foreground": "white",
+    "primary-hover": "var(--primary-700)",
+    "primary-border": "transparent",
+    "secondary": "white",
+    "secondary-foreground": "var(--neutral-900)",
+    "secondary-hover": "var(--neutral-100)",
+    "secondary-border": "var(--neutral-300)",
+    "success": "#16a34a",
+    "success-subtle": "#f0fdf4",
+    "warning": "#d97706",
+    "warning-subtle": "#fffbeb",
+    "error": "#dc2626",
+    "error-subtle": "#fef2f2",
+    "info": "#2563eb",
+    "info-subtle": "#eff6ff"
+  },
+  dark: {
+    "section": "var(--neutral-950)",
+    "card": "var(--neutral-800)",
+    "muted": "var(--neutral-700)",
+    "body": "var(--neutral-50)",
+    "heading": "white",
+    "subtle": "var(--neutral-400)",
+    "border": "var(--neutral-700)",
+    "ring": "var(--primary-500)",
+    "link": "var(--primary-400)",
+    "link-hover": "var(--primary-300)",
+    // Stays lightened, unlike the light/medium contexts which use the exact
+    // brand at 500. Every text token here is lightened (body, subtle, link)
+    // because a mid-brand hue on a near-black surface often isn't legible —
+    // a navy or forest-green accent at 500 would effectively disappear. A site
+    // whose brand does read on dark can set `contexts.dark.accent` to it.
+    "accent": "var(--accent-400)",
+    "primary": "var(--primary-500)",
+    "primary-foreground": "white",
+    "primary-hover": "var(--primary-400)",
+    "primary-border": "transparent",
+    "secondary": "var(--neutral-800)",
+    "secondary-foreground": "var(--neutral-100)",
+    "secondary-hover": "var(--neutral-700)",
+    "secondary-border": "var(--neutral-600)",
+    "success": "#4ade80",
+    "success-subtle": "#052e16",
+    "warning": "#fbbf24",
+    "warning-subtle": "#451a03",
+    "error": "#f87171",
+    "error-subtle": "#450a0a",
+    "info": "#60a5fa",
+    "info-subtle": "#172554"
+  }
+};
+var DEFAULT_COLORS = {
+  primary: "#3b82f6",
+  // Blue
+  secondary: "#64748b",
+  // Slate
+  // Last resort only. A site that names no accent inherits its primary (see
+  // processTheme) — this literal is reached solely when the primary is unusable.
+  accent: "#8b5cf6",
+  // Purple
+  neutral: "#78716c"
+  // Stone
+};
+var SHADE_LEVELS2 = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+function generateVarDeclarations(vars, indent = "  ") {
+  return Object.entries(vars).map(([name, value]) => `${indent}--${name}: ${value};`).join("\n");
+}
+function generatePaletteVars(palettes) {
+  const lines = [];
+  for (const [name, shades] of Object.entries(palettes)) {
+    for (const level of SHADE_LEVELS2) {
+      if (shades[level]) {
+        lines.push(`  --${name}-${level}: ${shades[level]};`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function generateContextCSS(context, tokens = {}, colorVars = {}) {
+  const defaultTokens = DEFAULT_CONTEXT_TOKENS[context] || DEFAULT_CONTEXT_TOKENS.light;
+  const mergedTokens = { ...defaultTokens, ...tokens };
+  const contextColorVars = colorVars[context] || {};
+  const allVars = { ...mergedTokens, ...contextColorVars };
+  const vars = generateVarDeclarations(allVars);
+  return `.context-${context} {
+${vars}
+}`;
+}
+function generateDarkSchemeCSS(config = {}, darkOverrides = {}, colorVars = {}) {
+  const respectSystemPreference = config.default === "system";
+  const darkColorVars = colorVars.dark || {};
+  const darkTokens = { ...DEFAULT_CONTEXT_TOKENS.dark, ...darkOverrides, ...darkColorVars };
+  const vars = generateVarDeclarations(darkTokens);
+  let css = `/* Dark scheme (user preference) */
+`;
+  css += `.scheme-dark {
+${vars}
+}
+`;
+  if (respectSystemPreference) {
+    css += `
+@media (prefers-color-scheme: dark) {
+`;
+    css += `  :root:not(.scheme-light) {
+`;
+    for (const [name, value] of Object.entries(darkTokens)) {
+      css += `    --${name}: ${value};
+`;
+    }
+    css += `  }
+`;
+    css += `}
+`;
+  }
+  return css;
+}
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-monospace",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "fangsong",
+  "inherit",
+  "initial",
+  "revert",
+  "unset"
+]);
+function extractUsedFamilies(fontRoles = {}) {
+  const used = /* @__PURE__ */ new Set();
+  const addFamiliesFrom = (value) => {
+    if (typeof value !== "string") return;
+    for (const segment of value.split(",")) {
+      const name = segment.trim().replace(/^["']|["']$/g, "").toLowerCase();
+      if (!name || GENERIC_FAMILIES.has(name) || /^\d/.test(name)) continue;
+      used.add(name);
+    }
+  };
+  for (const role of Object.values(fontRoles)) {
+    if (role && role.load) addFamiliesFrom(role.value);
+  }
+  return used;
+}
+function filterGoogleFontsUrl(url, usedFamilies) {
+  try {
+    const parsed = new URL(url);
+    const familyParams = parsed.searchParams.getAll("family");
+    if (familyParams.length === 0) return url;
+    const kept = familyParams.filter((param) => {
+      const name = param.split(":")[0].trim().toLowerCase();
+      return usedFamilies.has(name);
+    });
+    if (kept.length === 0) return null;
+    parsed.searchParams.delete("family");
+    for (const f of kept) {
+      parsed.searchParams.append("family", f);
+    }
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+function withBase(url, base) {
+  if (!url || !base || base === "/") return url;
+  if (!url.startsWith("/") || url.startsWith("//")) return url;
+  const prefix = base.endsWith("/") ? base.slice(0, -1) : base;
+  if (url === prefix || url.startsWith(prefix + "/")) return url;
+  return prefix + url;
+}
+function isGoogleFontsUrl(url) {
+  try {
+    return new URL(url).hostname === "fonts.googleapis.com";
+  } catch {
+    return false;
+  }
+}
+function generateFontCSS(fontRoles = {}, fonts = {}, base = "/") {
+  const cssLines = [];
+  const linkTags = [];
+  const usedFamilies = extractUsedFamilies(fontRoles);
+  const PRELOAD_TYPE = { woff2: "font/woff2", woff: "font/woff", truetype: "font/ttf", opentype: "font/otf" };
+  if (fonts.faces && Array.isArray(fonts.faces)) {
+    for (const face of fonts.faces) {
+      if (!face.family || !face.src) continue;
+      if (!usedFamilies.has(face.family.toLowerCase())) continue;
+      const format = face.format || (face.src.endsWith(".woff2") ? "woff2" : "woff");
+      const src = withBase(face.src, base);
+      cssLines.push(
+        `@font-face {`,
+        `  font-family: ${face.family};`,
+        `  src: url('${src}') format('${format}');`,
+        `  font-weight: ${face.weight || 400};`,
+        `  font-style: ${face.style || "normal"};`,
+        `  font-display: swap;`,
+        `}`
+      );
+      const mimeType = PRELOAD_TYPE[format];
+      if (mimeType) {
+        linkTags.push(`<link rel="preload" href="${src}" as="font" type="${mimeType}" crossorigin>`);
+      }
+    }
+    if (cssLines.length > 0) {
+      cssLines.push("");
+    }
+  }
+  const googleUrls = [];
+  const otherOrigins = /* @__PURE__ */ new Set();
+  if (fonts.import && Array.isArray(fonts.import)) {
+    for (const entry of fonts.import) {
+      if (!entry.url) continue;
+      if (isGoogleFontsUrl(entry.url)) {
+        const filtered = filterGoogleFontsUrl(entry.url, usedFamilies);
+        if (filtered) googleUrls.push(filtered);
+      } else {
+        linkTags.push(`<link rel="stylesheet" href="${entry.url}">`);
+        try {
+          otherOrigins.add(new URL(entry.url).origin);
+        } catch {
+        }
+      }
+    }
+  }
+  for (const origin of otherOrigins) {
+    linkTags.unshift(`<link rel="preconnect" href="${origin}">`);
+  }
+  if (googleUrls.length > 0) {
+    const allFamilies = [];
+    let display = "swap";
+    for (const url of googleUrls) {
+      try {
+        const parsed = new URL(url);
+        allFamilies.push(...parsed.searchParams.getAll("family"));
+        if (parsed.searchParams.get("display")) {
+          display = parsed.searchParams.get("display");
+        }
+      } catch {
+      }
+    }
+    if (allFamilies.length > 0) {
+      const familyQuery = allFamilies.map((f) => `family=${f.trim().replace(/\s+/g, "+")}`).join("&");
+      const href = `https://fonts.googleapis.com/css2?${familyQuery}&display=${display}`;
+      linkTags.unshift(
+        `<link rel="preconnect" href="https://fonts.googleapis.com">`,
+        `<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>`,
+        `<link rel="stylesheet" href="${href}">`
+      );
+    }
+  }
+  const fontVars = [];
+  for (const [name, role] of Object.entries(fontRoles)) {
+    if (role.value) {
+      fontVars.push(`  --font-${name}: ${role.value};`);
+    }
+  }
+  if (fontVars.length > 0) {
+    cssLines.push(":root {");
+    cssLines.push(...fontVars);
+    cssLines.push("}");
+  }
+  const applyRules = [];
+  for (const [name, role] of Object.entries(fontRoles)) {
+    if (!role.apply || !role.applyTo?.length) continue;
+    const selector = role.applyTo.join(", ");
+    applyRules.push(`${selector} { font-family: var(--font-${name}); }`);
+  }
+  if (applyRules.length > 0) {
+    cssLines.push("");
+    cssLines.push(...applyRules);
+  }
+  return {
+    css: cssLines.join("\n"),
+    links: linkTags.join("\n")
+  };
+}
+var RESERVED_VAR_NAMES = /* @__PURE__ */ new Set([
+  // Semantic color tokens
+  "section",
+  "card",
+  "muted",
+  "body",
+  "heading",
+  "subtle",
+  "border",
+  "ring",
+  "link",
+  "link-hover",
+  "accent",
+  // Action tokens
+  "primary",
+  "primary-foreground",
+  "primary-hover",
+  "primary-border",
+  "secondary",
+  "secondary-foreground",
+  "secondary-hover",
+  "secondary-border",
+  // Status tokens
+  "success",
+  "success-subtle",
+  "warning",
+  "warning-subtle",
+  "error",
+  "error-subtle",
+  "info",
+  "info-subtle"
+]);
+var PALETTE_SHADE_RE = /^(primary|secondary|accent|neutral)-\d+$/;
+function generateFoundationVars(vars = {}) {
+  if (!vars || Object.keys(vars).length === 0) {
+    return "";
+  }
+  const declarations = [];
+  for (const [name, config] of Object.entries(vars)) {
+    if (RESERVED_VAR_NAMES.has(name) || PALETTE_SHADE_RE.test(name)) {
+      console.warn(
+        `Warning: Foundation var '${name}' collides with a theme token. Rename it to avoid unexpected behavior (e.g., '${name}-value' or '${name}-size').`
+      );
+    }
+    const value = typeof config === "object" ? config.default : config;
+    if (value !== void 0) {
+      declarations.push(`  --${name}: ${value};`);
+    }
+  }
+  if (declarations.length === 0) {
+    return "";
+  }
+  return `:root {
+${declarations.join("\n")}
+}`;
+}
+function generateThemeCSS(config = {}, options = {}) {
+  const { base = "/" } = options;
+  const {
+    colors = DEFAULT_COLORS,
+    contexts = {},
+    fonts = {},
+    fontRoles = {},
+    appearance = {},
+    foundationVars = {},
+    colorVars = {}
+  } = config;
+  const sections = [];
+  const fontResult = generateFontCSS(fontRoles, fonts, base);
+  if (fontResult.css) {
+    sections.push("/* Typography */\n" + fontResult.css);
+  }
+  const palettes = generatePalettes(colors);
+  const paletteVars = generatePaletteVars(palettes);
+  sections.push(`/* Color Palettes */
+:root {
+${paletteVars}
+}`);
+  const lightColorVars = colorVars.light || {};
+  const defaultTokens = { ...DEFAULT_CONTEXT_TOKENS.light, ...contexts.light || {}, ...lightColorVars };
+  const defaultVars = generateVarDeclarations(defaultTokens);
+  sections.push(`/* Default Semantic Tokens */
+:root {
+${defaultVars}
+}
+
+/* Section backgrounds \u2014 applied once, resolves via context tokens */
+[id^="section-"] {
+  background-color: var(--section);
+}`);
+  const contextCSS = [
+    generateContextCSS("light", contexts.light, colorVars),
+    generateContextCSS("medium", contexts.medium, colorVars),
+    generateContextCSS("dark", contexts.dark, colorVars)
+  ];
+  sections.push("/* Color Contexts */\n" + contextCSS.join("\n\n"));
+  const foundationCSS = generateFoundationVars(foundationVars);
+  if (foundationCSS) {
+    sections.push("/* Foundation Variables */\n" + foundationCSS);
+  }
+  if (appearance.allowToggle || appearance.default === "dark" || appearance.default === "system" || appearance.schemes?.includes("dark")) {
+    sections.push(generateDarkSchemeCSS(appearance, contexts.dark, colorVars));
+  }
+  sections.push(
+    `/* Site Background */
+body {
+  background: ${config.background || "var(--section)"};
+}`
+  );
+  if (config.inline && typeof config.inline === "object") {
+    const rules = Object.entries(config.inline).filter(([, styles]) => styles && typeof styles === "object").map(([name, styles]) => {
+      const declarations = Object.entries(styles).map(([prop, value]) => `  ${prop}: ${value};`).join("\n");
+      return `span[${name}] {
+${declarations}
+}`;
+    });
+    if (rules.length > 0) {
+      sections.push("/* Inline Text Styles */\n" + rules.join("\n\n"));
     }
   }
-  return palettes;
+  return {
+    css: sections.join("\n\n"),
+    links: fontResult.links
+  };
+}
+function getDefaultContextTokens() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONTEXT_TOKENS));
+}
+function getDefaultColors() {
+  return { ...DEFAULT_COLORS };
 }
 
 // ../theming/src/normalize.js
-var SHADE_LEVELS2 = /* @__PURE__ */ new Set([50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950]);
+var SHADE_LEVELS3 = /* @__PURE__ */ new Set([50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950]);
 var PALETTE_REF_RE = /^([a-z][a-z0-9]*)-(\d+)$/;
 var PALETTE_REF_OPACITY_RE = /^([a-z][a-z0-9]*-\d+)\/(\d+)$/;
 var RGBA_VAR_RE = /^rgba\(\s*(var\(--[^)]+\))\s*\/\s*([\d.]+)\s*\)$/;
@@ -23957,7 +24480,7 @@ function normalizeTokenValue(value) {
     const ref = opacityMatch[1];
     const pct = parseInt(opacityMatch[2], 10);
     const refMatch = ref.match(PALETTE_REF_RE);
-    if (refMatch && SHADE_LEVELS2.has(parseInt(refMatch[2], 10))) {
+    if (refMatch && SHADE_LEVELS3.has(parseInt(refMatch[2], 10))) {
       if (pct >= 100) return `var(--${ref})`;
       return `color-mix(in srgb, var(--${ref}) ${pct}%, transparent)`;
     }
@@ -23965,13 +24488,413 @@ function normalizeTokenValue(value) {
   const paletteMatch = bare.match(PALETTE_REF_RE);
   if (paletteMatch) {
     const shade = parseInt(paletteMatch[2], 10);
-    if (SHADE_LEVELS2.has(shade)) {
+    if (SHADE_LEVELS3.has(shade)) {
       return `var(--${bare})`;
     }
   }
   return value;
 }
 
+// ../theming/src/processor.js
+var NEUTRAL_PRESETS = {
+  stone: "#78716c",
+  zinc: "#71717a",
+  gray: "#6b7280",
+  slate: "#64748b",
+  neutral: "#737373"
+};
+var DEFAULT_INLINE = {
+  accent: {
+    color: "var(--accent)",
+    "font-weight": "600"
+  },
+  callout: {
+    color: "var(--accent)",
+    "font-weight": "600"
+  },
+  muted: {
+    color: "var(--subtle)"
+  }
+};
+var DEFAULT_APPEARANCE = {
+  default: "light",
+  // Default color scheme
+  allowToggle: false,
+  // Whether to show scheme toggle
+  respectSystemPreference: true
+  // Honor prefers-color-scheme
+};
+var DEFAULT_FONTS = {
+  body: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+  heading: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+  code: 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, Consolas, monospace'
+};
+var DEFAULT_FONT_ROLES = {
+  body: ["body"],
+  heading: ["h1", "h2", "h3"],
+  code: ["code", "pre", "kbd", "samp"]
+};
+var NON_FAMILY_FONT_VARS = /* @__PURE__ */ new Set([
+  "font-weight",
+  "font-style",
+  "font-size",
+  "font-stretch",
+  "font-feature-settings",
+  "font-variation-settings",
+  "font-variant",
+  "font-kerning",
+  "font-optical-sizing",
+  "font-synthesis",
+  "font-size-adjust",
+  "font-smoothing",
+  "font-palette",
+  "font-language-override"
+]);
+function isFontVar(name, config) {
+  const type = typeof config === "object" ? config?.type : void 0;
+  if (type === "font") return true;
+  return name.startsWith("font-") && !NON_FAMILY_FONT_VARS.has(name);
+}
+function normalizeFontRoleName(name) {
+  return name.startsWith("font-") ? name.slice(5) : name;
+}
+function normalizeApplyTo(applyTo) {
+  if (applyTo == null) return null;
+  const list = Array.isArray(applyTo) ? applyTo : String(applyTo).split(",");
+  const cleaned = list.map((s) => String(s).trim()).filter(Boolean);
+  return cleaned.length ? cleaned : null;
+}
+function validateColors(colors) {
+  const errors = [];
+  if (!colors || typeof colors !== "object") {
+    return { valid: true, errors };
+  }
+  for (const [name, value] of Object.entries(colors)) {
+    if (typeof value === "object" && value !== null) {
+      continue;
+    }
+    if (typeof value !== "string") {
+      errors.push(`Color "${name}" must be a string or shade object, got ${typeof value}`);
+      continue;
+    }
+    if (name === "neutral" && NEUTRAL_PRESETS[value]) {
+      continue;
+    }
+    if (!isValidColor(value)) {
+      errors.push(`Color "${name}" has invalid value: ${value}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateContexts(contexts) {
+  const errors = [];
+  if (!contexts || typeof contexts !== "object") {
+    return { valid: true, errors };
+  }
+  const validContexts = ["light", "medium", "dark"];
+  for (const [context, tokens] of Object.entries(contexts)) {
+    if (!validContexts.includes(context)) {
+      errors.push(`Unknown context "${context}". Valid contexts: ${validContexts.join(", ")}`);
+      continue;
+    }
+    if (typeof tokens !== "object" || tokens === null) {
+      errors.push(`Context "${context}" must be an object`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateFonts(fonts) {
+  const errors = [];
+  if (!fonts || typeof fonts !== "object") {
+    return { valid: true, errors };
+  }
+  if (fonts.import !== void 0) {
+    if (!Array.isArray(fonts.import)) {
+      errors.push("fonts.import must be an array");
+    } else {
+      for (const [index, item] of fonts.import.entries()) {
+        if (typeof item !== "object" || !item.url) {
+          errors.push(`fonts.import[${index}] must have a "url" property`);
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateAppearance(appearance) {
+  const errors = [];
+  if (!appearance || typeof appearance !== "object") {
+    if (typeof appearance === "string") {
+      if (!["light", "dark", "system"].includes(appearance)) {
+        errors.push(`Invalid appearance value: ${appearance}. Must be "light", "dark", or "system"`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  if (appearance.default && !["light", "dark", "system"].includes(appearance.default)) {
+    errors.push(`Invalid appearance.default: ${appearance.default}`);
+  }
+  if (appearance.schemes !== void 0) {
+    if (!Array.isArray(appearance.schemes)) {
+      errors.push("appearance.schemes must be an array");
+    } else {
+      const validSchemes = ["light", "dark"];
+      for (const scheme of appearance.schemes) {
+        if (!validSchemes.includes(scheme)) {
+          errors.push(`Invalid scheme: ${scheme}. Valid schemes: ${validSchemes.join(", ")}`);
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateCodeTheme(code) {
+  const errors = [];
+  if (!code || typeof code !== "object") {
+    return { valid: true, errors };
+  }
+  for (const [name, value] of Object.entries(code)) {
+    if (typeof value !== "string") {
+      errors.push(`code.${name} must be a string, got ${typeof value}`);
+      continue;
+    }
+    if (!isValidColor(value)) {
+      errors.push(`code.${name} has invalid color value: ${value}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+var CONTEXT_AWARE_TYPES = /* @__PURE__ */ new Set(["color", "gradient"]);
+function validateFoundationVars(vars) {
+  const errors = [];
+  if (!vars || typeof vars !== "object") {
+    return { valid: true, errors };
+  }
+  for (const [name, config] of Object.entries(vars)) {
+    if (!/^[a-z][a-z0-9-]*$/i.test(name)) {
+      errors.push(`Invalid variable name "${name}". Use lowercase letters, numbers, and hyphens.`);
+    }
+    if (typeof config !== "object" && typeof config !== "string" && typeof config !== "number") {
+      errors.push(`Variable "${name}" must have a string, number, or config object value`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateThemeConfig(config) {
+  const allErrors = [];
+  if (!config || typeof config !== "object") {
+    return { valid: true, errors: [] };
+  }
+  const colorValidation = validateColors(config.colors);
+  const contextValidation = validateContexts(config.contexts);
+  const fontValidation = validateFonts(config.fonts);
+  const appearanceValidation = validateAppearance(config.appearance);
+  const codeValidation = validateCodeTheme(config.code);
+  allErrors.push(...colorValidation.errors);
+  allErrors.push(...contextValidation.errors);
+  allErrors.push(...fontValidation.errors);
+  allErrors.push(...appearanceValidation.errors);
+  allErrors.push(...codeValidation.errors);
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors
+  };
+}
+function mergeInlineStyles(defaults, overrides) {
+  const merged = { ...defaults };
+  for (const [name, style] of Object.entries(overrides || {})) {
+    merged[name] = style && typeof style === "object" && !Array.isArray(style) ? { ...defaults[name] || {}, ...style } : style;
+  }
+  return merged;
+}
+function normalizeAppearance(appearance) {
+  if (!appearance) {
+    return { ...DEFAULT_APPEARANCE };
+  }
+  if (typeof appearance === "string") {
+    return {
+      default: appearance,
+      allowToggle: false,
+      respectSystemPreference: appearance === "system"
+    };
+  }
+  return {
+    ...DEFAULT_APPEARANCE,
+    ...appearance
+  };
+}
+function mergeFoundationVars(foundationVars = {}, siteVars = {}) {
+  const flat = {};
+  const colorVars = {};
+  for (const [name, config] of Object.entries(foundationVars)) {
+    const cfg = typeof config === "object" ? { ...config } : { default: config };
+    const isContextAware = CONTEXT_AWARE_TYPES.has(cfg.type);
+    if (isContextAware) {
+      const defaultVal = cfg.default || "";
+      colorVars[name] = { light: defaultVal, dark: defaultVal };
+    } else {
+      flat[name] = cfg;
+    }
+  }
+  for (const [name, value] of Object.entries(siteVars)) {
+    const schemaCfg = foundationVars[name];
+    const type = typeof schemaCfg === "object" ? schemaCfg?.type : void 0;
+    const isContextAware = CONTEXT_AWARE_TYPES.has(type);
+    if (isContextAware) {
+      if (typeof value === "object" && value !== null && (value.light || value.dark)) {
+        colorVars[name] = { ...colorVars[name] || {}, ...value };
+      } else {
+        const strVal = String(value);
+        colorVars[name] = { light: strVal, dark: strVal };
+      }
+    } else {
+      if (flat[name]) {
+        flat[name].default = value;
+      } else {
+        flat[name] = { default: value };
+      }
+    }
+  }
+  return { flat, colorVars };
+}
+function processTheme(rawConfig = {}, options = {}) {
+  const { foundationVars = {}, strict = false } = options;
+  const errors = [];
+  const warnings = [];
+  const validation = validateThemeConfig(rawConfig);
+  if (!validation.valid) {
+    errors.push(...validation.errors);
+    if (strict) {
+      throw new Error(`Theme configuration errors:
+${errors.join("\n")}`);
+    }
+  }
+  const defaultColors = getDefaultColors();
+  const rawColors = { ...rawConfig.colors || {} };
+  if (typeof rawColors.neutral === "string" && NEUTRAL_PRESETS[rawColors.neutral]) {
+    rawColors.neutral = NEUTRAL_PRESETS[rawColors.neutral];
+  }
+  const brandColor = rawColors.primary ?? defaultColors.primary;
+  const isUsableColor = (v) => typeof v === "object" && v !== null || isValidColor(v);
+  if (rawColors.accent === void 0 && isUsableColor(brandColor)) {
+    rawColors.accent = brandColor;
+  }
+  const validColors = {};
+  for (const [name, value] of Object.entries({ ...defaultColors, ...rawColors })) {
+    if (typeof value === "object" && value !== null) {
+      validColors[name] = value;
+    } else if (isValidColor(value)) {
+      validColors[name] = value;
+    }
+  }
+  const colors = validColors;
+  const palettes = generatePalettes(colors);
+  if (!rawConfig.colors?.primary) {
+    warnings.push("No primary color specified, using default blue (#3b82f6)");
+  }
+  if (!rawConfig.colors?.neutral) {
+    warnings.push("No neutral color specified, using default stone (#78716c)");
+  }
+  const defaultContexts = getDefaultContextTokens();
+  const rawContexts = rawConfig.contexts || {};
+  const contexts = {};
+  for (const name of ["light", "medium", "dark"]) {
+    const overrides = rawContexts[name] || {};
+    const normalized = {};
+    for (const [token, value] of Object.entries(overrides)) {
+      normalized[token] = normalizeTokenValue(value);
+    }
+    contexts[name] = { ...defaultContexts[name], ...normalized };
+  }
+  const rawFonts = { ...rawConfig.fonts || {} };
+  const appearance = normalizeAppearance(rawConfig.appearance);
+  const { flat: mergedFoundationVars, colorVars } = mergeFoundationVars(
+    foundationVars,
+    rawConfig.vars || rawConfig.foundationVars || {}
+  );
+  const foundationValidation = validateFoundationVars(mergedFoundationVars);
+  if (!foundationValidation.valid) {
+    warnings.push(...foundationValidation.errors);
+  }
+  const fontRoles = {};
+  for (const [name, applyTo] of Object.entries(DEFAULT_FONT_ROLES)) {
+    fontRoles[name] = {
+      value: DEFAULT_FONTS[name],
+      applyTo: [...applyTo],
+      foundationOwned: false,
+      userSet: false
+    };
+  }
+  const nonFontVars = {};
+  for (const [rawName, cfg] of Object.entries(mergedFoundationVars)) {
+    if (!isFontVar(rawName, cfg)) {
+      nonFontVars[rawName] = cfg;
+      continue;
+    }
+    const name = normalizeFontRoleName(rawName);
+    const cfgObj = typeof cfg === "object" ? cfg : { default: cfg };
+    const existing = fontRoles[name];
+    fontRoles[name] = {
+      value: cfgObj.default ?? existing?.value,
+      applyTo: cfgObj.applyTo !== void 0 ? normalizeApplyTo(cfgObj.applyTo) : existing?.applyTo ?? null,
+      foundationOwned: true,
+      userSet: false
+    };
+  }
+  const FONT_LOADING_KEYS = /* @__PURE__ */ new Set(["import", "faces"]);
+  for (const [rawName, value] of Object.entries(rawFonts)) {
+    if (FONT_LOADING_KEYS.has(rawName)) continue;
+    const name = normalizeFontRoleName(rawName);
+    const existing = fontRoles[name];
+    fontRoles[name] = {
+      value,
+      applyTo: existing?.applyTo ?? null,
+      foundationOwned: existing?.foundationOwned ?? false,
+      userSet: true
+    };
+  }
+  for (const role of Object.values(fontRoles)) {
+    const intended = role.foundationOwned || role.userSet;
+    role.apply = intended && Array.isArray(role.applyTo) && role.applyTo.length > 0;
+    role.load = intended;
+  }
+  if (rawFonts.mono !== void 0 && !fontRoles.mono?.foundationOwned) {
+    warnings.push("theme.yml `fonts.mono` is not a built-in font role \u2014 the code/monospace role is `code`. Rename `fonts.mono` \u2192 `fonts.code`.");
+  }
+  const fonts = {};
+  if (rawFonts.import !== void 0) fonts.import = rawFonts.import;
+  if (rawFonts.faces !== void 0) fonts.faces = rawFonts.faces;
+  for (const [name, role] of Object.entries(fontRoles)) {
+    fonts[name] = role.value;
+  }
+  const code = rawConfig.code ?? null;
+  const background = rawConfig.background || null;
+  const inline = mergeInlineStyles(DEFAULT_INLINE, rawConfig.inline);
+  const config = {
+    colors,
+    // Raw colors for CSS generator
+    palettes,
+    // Generated palettes for Theme class
+    contexts,
+    fonts,
+    // name→value (+ import/faces) for the Theme API and loading
+    fontRoles,
+    // resolved font-role map (value/applyTo/apply/load) for CSS gen
+    appearance,
+    foundationVars: nonFontVars,
+    // NON-font vars only (font vars live in fontRoles)
+    colorVars,
+    // Context-aware vars: { light: {...}, dark: {...} }
+    code,
+    // Code block theme for runtime injection
+    background,
+    // Site-level background CSS value
+    inline
+    // Inline text style definitions
+  };
+  return { config, errors, warnings };
+}
+
 // ../theming/src/section-overrides.js
 function hasOverrides(standardOptions) {
   if (!standardOptions) return false;
@@ -24074,7 +24997,53 @@ function buildSectionOverrides(blocks, appearance = {}) {
   return css;
 }
 
+// ../theming/src/index.js
+function buildTheme(themeYml = {}, options = {}) {
+  const { config, errors, warnings } = processTheme(themeYml, options);
+  const { css, links } = generateThemeCSS(config, { base: options.base });
+  return {
+    css,
+    links,
+    config,
+    errors,
+    warnings
+  };
+}
+
 // ../core/src/block.js
+function liftContainers(content) {
+  if (!content || !Array.isArray(content.content)) return { content, refs: [] };
+  const refs = [];
+  const visit3 = (nodes) => {
+    let changed = false;
+    const out = nodes.map((node) => {
+      if (!node) return node;
+      if (node.type === "inset_block") {
+        const { component, ...params } = node.attrs || {};
+        const refId = `container_${refs.length}`;
+        refs.push({
+          refId,
+          type: component,
+          params,
+          content: { type: "doc", content: node.content || [] }
+        });
+        changed = true;
+        return { type: "inset_placeholder", attrs: { refId, embedKind: "block" } };
+      }
+      if (Array.isArray(node.content)) {
+        const inner = visit3(node.content);
+        if (inner !== node.content) {
+          changed = true;
+          return { ...node, content: inner };
+        }
+      }
+      return node;
+    });
+    return changed ? out : nodes;
+  };
+  const next = visit3(content.content);
+  return next === content.content ? { content, refs } : { content: { ...content, content: next }, refs };
+}
 var Block = class _Block {
   constructor(blockData, id, page) {
     this.id = id;
@@ -24083,8 +25052,9 @@ var Block = class _Block {
     this.website = page.website;
     this.type = blockData.type || this.website.getDefaultBlockType();
     this.Component = null;
-    this.rawContent = blockData.content || {};
-    this.parsedContent = this.parseContent(blockData.content);
+    const lifted = liftContainers(blockData.content);
+    this.rawContent = lifted.content || {};
+    this.parsedContent = this.parseContent(lifted.content);
     if (blockData.parsedContent?.data) {
       this.parsedContent.data = {
         ...this.parsedContent.data || {},
@@ -24143,6 +25113,22 @@ var Block = class _Block {
         this.insets.push(child);
       }
     }
+    for (let i = 0; i < lifted.refs.length; i++) {
+      const ref = lifted.refs[i];
+      this.insets.push(
+        new _Block(
+          {
+            type: ref.type,
+            params: ref.params || {},
+            content: ref.content,
+            stableId: ref.refId,
+            refId: ref.refId
+          },
+          `${id}_container_${i}`,
+          this.page
+        )
+      );
+    }
     this.fetch = blockData.fetch || null;
     this.dataLoading = false;
     this.hasBackground = false;
@@ -24389,6 +25375,10 @@ var Block = class _Block {
    * @returns {Object|null} Next block's info or null
    */
   getNextBlockInfo() {
+    const active = this.website?.activePage;
+    if (active && active !== this.page) {
+      return active.getFirstBodyBlockInfo();
+    }
     const index = this.getIndex();
     if (index < 0 || !this.page) return null;
     return this.page.getBlockInfo(index + 1);
@@ -24399,6 +25389,10 @@ var Block = class _Block {
    * @returns {Object|null} Previous block's info or null
    */
   getPrevBlockInfo() {
+    const active = this.website?.activePage;
+    if (active && active !== this.page) {
+      return active.getLastBodyBlockInfo();
+    }
     const index = this.getIndex();
     if (index <= 0 || !this.page) return null;
     return this.page.getBlockInfo(index - 1);
@@ -24621,6 +25615,20 @@ var ObservableState = class {
   }
 };
 
+// ../core/src/seo.js
+function normalizeSeo(raw) {
+  const seo = raw || {};
+  return {
+    noindex: seo.noindex || false,
+    image: seo.image || null,
+    ogTitle: seo.ogTitle || null,
+    ogDescription: seo.ogDescription || null,
+    canonical: seo.canonical || null,
+    changefreq: seo.changefreq || null,
+    priority: seo.priority || null
+  };
+}
+
 // ../core/src/page.js
 function normalizeHideIn(pageData) {
   const out = [];
@@ -24662,15 +25670,7 @@ var Page = class {
       hide: pageData.layout?.hide || [],
       params: pageData.layout?.params || {}
     };
-    this.seo = {
-      noindex: pageData.seo?.noindex || false,
-      image: pageData.seo?.image || null,
-      ogTitle: pageData.seo?.ogTitle || null,
-      ogDescription: pageData.seo?.ogDescription || null,
-      canonical: pageData.seo?.canonical || null,
-      changefreq: pageData.seo?.changefreq || null,
-      priority: pageData.seo?.priority || null
-    };
+    this.seo = normalizeSeo(pageData.seo);
     this.parent = null;
     this.children = [];
     this.website = website;
@@ -24716,16 +25716,20 @@ var Page = class {
    */
   getHeadMeta() {
     const resolvedTitle = this.getTitle();
+    const site = this.website?.seo || {};
+    const siteKeywords = this.website?.keywords || null;
     return {
       title: resolvedTitle,
       description: this.description,
-      keywords: this.keywords,
+      keywords: this.keywords || siteKeywords,
       canonical: this.seo.canonical,
-      robots: this.seo.noindex ? "noindex, nofollow" : null,
+      robots: this.seo.noindex || site.noindex ? "noindex, nofollow" : null,
       og: {
-        title: this.seo.ogTitle || resolvedTitle,
-        description: this.seo.ogDescription || this.description,
-        image: this.seo.image,
+        // Page content wins; site-level seo only fills gaps. Image is the
+        // exception authors most want cascaded (the shared social card).
+        title: this.seo.ogTitle || resolvedTitle || site.ogTitle,
+        description: this.seo.ogDescription || this.description || site.ogDescription,
+        image: this.seo.image || site.image,
         url: this.route
       }
     };
@@ -24812,6 +25816,17 @@ var Page = class {
   getFirstBodyBlockInfo() {
     return this.bodyBlocks?.[0]?.getBlockInfo() || null;
   }
+  /**
+   * Get the last body block's info.
+   * Symmetric to getFirstBodyBlockInfo — e.g. a footer adapting to the
+   * content section directly above it.
+   *
+   * @returns {Object|null} Last body block's info or null
+   */
+  getLastBodyBlockInfo() {
+    const blocks = this.bodyBlocks;
+    return blocks?.[blocks.length - 1]?.getBlockInfo() || null;
+  }
   /**
    * Get all blocks (header, body, footer) as flat array
    * Respects page layout preferences (hide list)
@@ -24927,11 +25942,13 @@ var Page = class {
   /**
    * Check if page should appear in a named nav area ('header', 'footer', or any
    * foundation-declared area). The general form behind showInHeader/showInFooter.
+   * False when the page is unpublished (`hidden`), suppressed from every area
+   * (`hideIn` contains '*'), or suppressed from this specific area.
    * @param {string} area
    * @returns {boolean}
    */
   showInNav(area) {
-    return !this.hidden && !this.hideIn.includes(area);
+    return !this.hidden && !this.hideIn.includes("*") && !this.hideIn.includes(area);
   }
   /**
    * Check if page should appear in header navigation
@@ -25307,10 +26324,52 @@ function substitutePlaceholders(value, context, options = {}) {
   return value;
 }
 
-// ../core/src/entity-store.js
-function isRefinement(bf) {
-  return bf?.refine === true || bf?.inherit === true;
+// ../core/src/fetch-config.js
+function isFetchRefinement(cfg) {
+  return cfg?.refine === true || cfg?.inherit === true;
+}
+function localizeConfig(cfg, locale, defaultLocale) {
+  if (!cfg.path) return cfg;
+  if (!locale || locale === defaultLocale) return cfg;
+  if (!cfg.path.startsWith("/data/")) return cfg;
+  return { ...cfg, path: `/${locale}${cfg.path}` };
+}
+function applyDeferredDetail(cfg, collections) {
+  if (cfg.detail !== void 0) return cfg;
+  const schema4 = cfg.schema;
+  if (!schema4 || !collections) return cfg;
+  const collConfig = collections[schema4];
+  if (!collConfig || typeof collConfig !== "object") return cfg;
+  const deferred = Array.isArray(collConfig.deferred) ? collConfig.deferred : null;
+  if (!deferred || deferred.length === 0) return cfg;
+  const pattern = typeof collConfig.detailUrl === "string" ? collConfig.detailUrl : `/data/${schema4}/{slug}.json`;
+  return { ...cfg, detail: pattern };
+}
+function resolveFetchConfigs(sources, options = {}) {
+  const {
+    schemas: schemas2 = [],
+    locale = null,
+    defaultLocale = null,
+    collections = null
+  } = options;
+  const configs = /* @__PURE__ */ new Map();
+  const collectAll = schemas2.length === 0;
+  for (const source of sources) {
+    if (!source) continue;
+    const configList = Array.isArray(source) ? source : [source];
+    for (const cfg of configList) {
+      if (!cfg?.schema) continue;
+      if (configs.has(cfg.schema)) continue;
+      if (!collectAll && !schemas2.includes(cfg.schema)) continue;
+      const localized = localizeConfig(cfg, locale, defaultLocale);
+      configs.set(cfg.schema, applyDeferredDetail(localized, collections));
+    }
+  }
+  return configs;
 }
+
+// ../core/src/entity-store.js
+var isRefinement = isFetchRefinement;
 var inheritDeprecationWarned = false;
 function warnInheritDeprecation(block) {
   if (inheritDeprecationWarned) return;
@@ -25367,93 +26426,58 @@ var EntityStore = class {
     if (meta.inheritData === false) return null;
     return [];
   }
-  /**
-   * Return a localized copy of a fetch config for collection data.
-   * Non-default locales get /{locale} prefixed onto /data/ paths so the
-   * client fetches the translated JSON (/fr/data/articles.json).
-   */
-  _localizeConfig(cfg, website) {
-    if (!cfg.path || !website) return cfg;
-    const locale = website.getActiveLocale?.();
-    const defaultLocale = website.getDefaultLocale?.();
-    if (!locale || locale === defaultLocale) return cfg;
-    if (!cfg.path.startsWith("/data/")) return cfg;
-    return { ...cfg, path: `/${locale}${cfg.path}` };
-  }
   /**
    * Walk the four-level hierarchy and collect fetch configs for the
    * requested schemas. First match per schema wins.
+   *
+   * This method's job is to read the four source slots off the object graph;
+   * the rule applied to them (precedence, first-match-per-schema, locale
+   * normalization, deferred-detail injection) lives in `./fetch-config.js`,
+   * shared with every other host that has to answer the same question. Do not
+   * re-inline it here — divergence between copies is what the extraction
+   * exists to prevent.
    */
   _findFetchConfigs(block, requested) {
-    const configs = /* @__PURE__ */ new Map();
-    const collectAll = requested.length === 0;
-    const sources = [];
     if (block.fetch?.inherit === true && block.fetch?.refine !== true) {
       warnInheritDeprecation(block);
     }
-    if (block.fetch && !isRefinement(block.fetch)) sources.push(block.fetch);
     const page = block.page;
-    if (page?.fetch) sources.push(page.fetch);
-    if (page?.parent?.fetch) sources.push(page.parent.fetch);
-    const siteFetch = block.website?.config?.fetch;
-    if (siteFetch) sources.push(siteFetch);
     const website = block.website;
-    for (const source of sources) {
-      const configList = Array.isArray(source) ? source : [source];
-      for (const cfg of configList) {
-        if (!cfg.schema) continue;
-        if (configs.has(cfg.schema)) continue;
-        if (collectAll || requested.includes(cfg.schema)) {
-          const localized = this._localizeConfig(cfg, website);
-          const withDetail = this._applyDeferredDetail(localized, website);
-          configs.set(cfg.schema, withDetail);
-        }
+    return resolveFetchConfigs(
+      [
+        block.fetch && !isRefinement(block.fetch) ? block.fetch : null,
+        page?.fetch,
+        page?.parent?.fetch,
+        website?.config?.fetch
+      ],
+      {
+        schemas: requested,
+        locale: website?.getActiveLocale?.() ?? null,
+        defaultLocale: website?.getDefaultLocale?.() ?? null,
+        collections: website?.config?.collections ?? null
       }
-    }
-    return configs;
+    );
   }
   /**
-   * Auto-inject `detail:` on collection refs whose collection has
-   * `deferred:` declared. The detail pattern points at the per-record
-   * source so the existing dynamic-route singular flow fetches a record
-   * with all fields (including the deferred ones) instead of the
-   * matched-item-from-the-cascade-collection (without).
-   *
-   * Two patterns:
-   *
-   *   - Markdown-backed collections (the build emits per-record files
-   *     at `/data/<name>/<slug>.json`): the auto-injected pattern is
-   *     that path. `isLocalPath` resolution downstream gives the
-   *     fetch a `path:` shape.
-   *
-   *   - API-backed collections (the source is a remote URL; the build
-   *     emits no per-record files): the author declares a `detailUrl:`
-   *     on the collection — e.g., `/api/articles/{slug}` — and the
-   *     auto-injected pattern uses it. `isLocalPath` resolution
-   *     downstream gives the fetch a `url:` shape (because the
-   *     collection itself has `url:`, not `path:`).
-   *
-   * Conventions:
-   *   - Per-record sources are keyed by `item.slug`. The injected
-   *     pattern uses the `{slug}` placeholder; substitution works when
-   *     the dynamic route's paramName is 'slug' (the documented
-   *     convention). Routes with other param names need an explicit
-   *     author-written `detail:` value.
-   *   - Author-supplied `cfg.detail` always wins. This helper only fills
-   *     in the default for collections that have declared deferred fields.
-   *   - Per-record files are not currently localized; sites needing
-   *     localized deferred collections write their own `detail:` URL.
+   * Post-process assembled collection data: for each fetch config that declares a
+   * `detailPage` page-ref, resolve it to a locale route template (O(1), via the
+   * Website's `_pageIdMap`) and inject a `route` on each record — so a dynamic-list
+   * card links to the collection's canonical detail page regardless of which page
+   * the list sits on. Runs after `data` is fully assembled, in BOTH the sync (peek)
+   * and async (fetch) paths. Replaces the old runtime `getCollectionDetailRoute`
+   * page-tree scan. A dangling `detailPage` (unresolvable ref) is a no-op — the
+   * component degrades gracefully; records with a baked `route` (file lane) are kept.
    */
-  _applyDeferredDetail(cfg, website) {
-    if (cfg.detail !== void 0) return cfg;
-    const schema4 = cfg.schema;
-    if (!schema4) return cfg;
-    const collConfig = website?.config?.collections?.[schema4];
-    if (!collConfig || typeof collConfig !== "object") return cfg;
-    const deferred = Array.isArray(collConfig.deferred) ? collConfig.deferred : null;
-    if (!deferred || deferred.length === 0) return cfg;
-    const pattern = typeof collConfig.detailUrl === "string" ? collConfig.detailUrl : `/data/${schema4}/{slug}.json`;
-    return { ...cfg, detail: pattern };
+  _applyDetailRoutes(data, configs, website) {
+    if (!data || !website?.resolveDetailPageTemplate) return;
+    for (const [schema4, cfg] of configs) {
+      if (!cfg.detailPage) continue;
+      const items = data[schema4];
+      if (!Array.isArray(items) || items.length === 0) continue;
+      const template = website.resolveDetailPageTemplate(cfg.detailPage);
+      if (!template) continue;
+      data[schema4] = items.map((item) => addDetailRoute(item, template));
+    }
   }
   /**
    * Build a detail-URL fetch config from a collection config + dynamic context.
@@ -25593,6 +26617,7 @@ var EntityStore = class {
       }
     }
     if (allCached) {
+      this._applyDetailRoutes(data, configs, block.website);
       return { status: "ready", data };
     }
     return { status: "pending", data: null };
@@ -25677,6 +26702,7 @@ var EntityStore = class {
       }
     }
     if (parallelFetches.length > 0) await Promise.all(parallelFetches);
+    this._applyDetailRoutes(data, configs, block.website);
     return { data };
   }
 };
@@ -25685,6 +26711,19 @@ function peekArray(dispatcher, cfg, ctx) {
   if (!cached) return null;
   return Array.isArray(cached.data) ? cached.data : null;
 }
+function addDetailRoute(item, template) {
+  if (!item || typeof item !== "object" || item.route !== void 0) return item;
+  let missing = false;
+  const route = template.replace(/:(\w+)/g, (_, name) => {
+    const value = item[name];
+    if (value == null) {
+      missing = true;
+      return "";
+    }
+    return encodeURIComponent(String(value));
+  });
+  return missing ? item : { ...item, route };
+}
 
 // ../core/src/fetcher-dispatcher.js
 function getFoundationDecl(mod) {
@@ -25951,6 +26990,113 @@ var FetcherDispatcher = class {
   }
 };
 
+// ../core/src/locale-config.js
+function codeOf(entry) {
+  if (typeof entry === "string" && entry.trim() && entry.trim() !== "*") return entry.trim();
+  if (entry && typeof entry === "object" && typeof entry.code === "string" && entry.code.trim()) {
+    return entry.code.trim();
+  }
+  return null;
+}
+function isWildcardLanguages(value) {
+  return value === "*" || Array.isArray(value) && value.includes("*");
+}
+function normalizeLanguageList(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const codes = [];
+  for (const entry of value) {
+    const code = codeOf(entry);
+    if (!code || seen.has(code)) continue;
+    seen.add(code);
+    codes.push(code);
+  }
+  return codes;
+}
+function resolveDefaultLocale(config = {}) {
+  if (typeof config?.defaultLanguage === "string" && config.defaultLanguage.trim()) {
+    return config.defaultLanguage.trim();
+  }
+  return normalizeLanguageList(config?.languages)[0] || "en";
+}
+function resolvePublishableLocales(config = {}) {
+  const declared = normalizeLanguageList(config?.languages);
+  const raw = config?.publishLanguages;
+  if (raw == null) return { publishable: declared, dangling: [], explicit: false };
+  const listed = normalizeLanguageList(raw);
+  if (isWildcardLanguages(config?.languages)) {
+    return { publishable: listed, dangling: [], explicit: true };
+  }
+  const declaredSet = new Set(declared);
+  const listedSet = new Set(listed);
+  return {
+    publishable: declared.filter((code) => listedSet.has(code)),
+    dangling: listed.filter((code) => !declaredSet.has(code)),
+    explicit: true
+  };
+}
+function validateLanguageConfig(config = {}) {
+  const errors = [];
+  const warnings = [];
+  const inspectList = (value, field, entryCode) => {
+    if (value == null) return;
+    if (value === "*") return;
+    if (!Array.isArray(value)) {
+      warnings.push({
+        code: entryCode,
+        message: `${field} must be a list of locale codes (got ${typeof value}) \u2014 ignored`
+      });
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of value) {
+      if (entry === "*") continue;
+      const code = codeOf(entry);
+      if (!code) {
+        warnings.push({
+          code: entryCode,
+          message: `${field} entry ${JSON.stringify(entry)} is not a locale code string \u2014 dropped`
+        });
+        continue;
+      }
+      if (typeof entry !== "string") {
+        warnings.push({
+          code: entryCode,
+          message: `${field} entry for '${code}' uses the legacy object form \u2014 use the plain string '${code}'`
+        });
+      }
+      if (seen.has(code)) {
+        warnings.push({ code: "duplicate-language", message: `${field} lists '${code}' more than once \u2014 deduped` });
+      }
+      seen.add(code);
+    }
+  };
+  inspectList(config?.languages, "languages", "invalid-language-entry");
+  inspectList(config?.publishLanguages, "publishLanguages", "invalid-publish-language-entry");
+  const { publishable, dangling, explicit } = resolvePublishableLocales(config);
+  for (const code of dangling) {
+    warnings.push({
+      code: "dangling-publish-language",
+      message: `publishLanguages lists '${code}' but languages does not declare it \u2014 ignored at publish (kept in the file so a re-declared language keeps its publish intent)`
+    });
+  }
+  if (explicit && publishable.length === 0) {
+    errors.push({
+      code: "nothing-publishable",
+      message: "publishLanguages leaves no publishable language (empty list, or nothing it lists is declared) \u2014 a publishable default language is required"
+    });
+  } else if (explicit) {
+    const defaultLocale = resolveDefaultLocale(config);
+    if (!publishable.includes(defaultLocale)) {
+      errors.push({
+        code: "default-not-publishable",
+        message: `the default language '${defaultLocale}' is not in publishLanguages \u2014 the effective default must be publishable`
+      });
+    }
+  }
+  return { errors, warnings };
+}
+
 // ../core/src/website.js
 var Website = class {
   constructor({
@@ -25989,6 +27135,8 @@ var Website = class {
     this.pageRoutes = [];
     this.themeData = {};
     this.config = {};
+    this.seo = {};
+    this.keywords = null;
     this.siteDefaultLocale = "en";
     this.defaultLocale = "en";
     this.activeLocale = "en";
@@ -26050,7 +27198,9 @@ var Website = class {
     this.pageRoutes = this.pages.map((page) => page.route);
     this.themeData = theme;
     this.config = config;
-    this.siteDefaultLocale = config.defaultLanguage || "en";
+    this.seo = normalizeSeo(config.seo);
+    this.keywords = config.keywords || null;
+    this.siteDefaultLocale = resolveDefaultLocale(config);
     this.defaultLocale = config.domainLocale || this.siteDefaultLocale;
     this.activeLocale = config.activeLocale || this.defaultLocale;
     this.locales = this.buildLocalesList(config);
@@ -26110,7 +27260,7 @@ var Website = class {
    * @private
    */
   buildLocalesList(config) {
-    const defaultLocale = config.defaultLanguage || "en";
+    const defaultLocale = resolveDefaultLocale(config);
     const languages = config.languages || [];
     const normalizeLocale = (locale) => {
       if (typeof locale === "string") {
@@ -26373,8 +27523,6 @@ var Website = class {
         pageData.title = "Not found";
         pageData.notFound = true;
       }
-      pageData.dynamicContext.currentItem = currentItem || null;
-      pageData.dynamicContext.allItems = items;
       pageData._collectionLoaded = items.length > 0;
     }
     const dynamicPage = new Page(pageData, `dynamic-${concreteRoute}`, this);
@@ -26531,6 +27679,34 @@ var Website = class {
     }
     return resolvedHref;
   }
+  /**
+   * Resolve a `page:<stable_id>` detail-page reference (from a fetch config's
+   * `detailPage`) to a locale-specific route TEMPLATE, e.g. '/blog/:slug'. The
+   * entity store interpolates each record's field into the `:param` slot to build
+   * a card's href — so a dynamic-list preview links to the collection's canonical
+   * detail page regardless of which page it sits on.
+   *
+   * O(1): a `_pageIdMap` lookup (keyed on stable_id, same map makeHref uses), NOT
+   * a page-tree scan. Returns null when the ref is unresolvable — the target page
+   * was deleted or de-dynamicized (a dangling ref); the caller degrades gracefully
+   * (leaves the record without a `route`). Rename-safe: a stable_id survives page
+   * reorganization.
+   *
+   * @param {string} pageRef - `page:<stable_id>` (bare `<stable_id>` also accepted)
+   * @returns {string|null} locale-specific route template, or null if unresolvable
+   */
+  resolveDetailPageTemplate(pageRef) {
+    if (!pageRef || typeof pageRef !== "string") return null;
+    const id = pageRef.startsWith("page:") ? pageRef.slice(5) : pageRef;
+    const page = this._pageIdMap?.get(id);
+    if (!page || !page.route) {
+      if (typeof console !== "undefined" && typeof process !== "undefined" && true) {
+        console.warn(`[resolveDetailPageTemplate] Detail page not found: ${pageRef}`);
+      }
+      return null;
+    }
+    return this.translateRoute(page.route);
+  }
   /**
    * Get available languages
    * @deprecated Use getLocales() instead
@@ -26677,6 +27853,21 @@ var Website = class {
     const config = this.config?.search || {};
     return {
       enabled: this.isSearchEnabled(),
+      // Which provider serves results. `index` (the default) downloads a
+      // prebuilt index and queries it in the browser — free, and works on any
+      // host. `endpoint` queries a server-side search API, which is what makes
+      // dynamic/API-backed content searchable. Any other value names a
+      // foundation-supplied search transport.
+      //
+      // Kit resolves and loads the provider; core only passes the declaration
+      // through, so a site that never searches pays nothing for the vocabulary
+      // (see kit's search module for the resolution rules).
+      provider: config.provider || "index",
+      // Base-RELATIVE path for the `endpoint` provider. Left raw here: kit
+      // resolves it against `basePath`, so one spelling works whether the site
+      // is served from the root, from a subdirectory, or from a backend
+      // subpath. Undefined unless declared.
+      endpoint: config.endpoint,
       indexUrl: this.getSearchIndexUrl(),
       locale: this.getActiveLocale(),
       include: {
@@ -26694,13 +27885,21 @@ var Website = class {
     };
   }
   /**
-   * Get the URL for the search index file
+   * Get the URL for the search index file.
+   *
+   * Includes `basePath`, so the URL is correct on a site deployed under a
+   * subdirectory (`base: /docs/`) and on a backend-hosted site served from a
+   * subpath. Omitting it was a real bug: the returned path was fetched
+   * verbatim, so search 404'd on every non-root deployment while data fetching
+   * — which resolves the same base — worked.
+   *
    * @returns {string} URL to fetch the search index
    */
   getSearchIndexUrl() {
     const locale = this.getActiveLocale();
     const isDefault = locale === this.getDefaultLocale();
-    return isDefault ? "/search-index.json" : `/${locale}/search-index.json`;
+    const path = isDefault ? "/search-index.json" : `/${locale}/search-index.json`;
+    return `${this.basePath || ""}${path}`;
   }
   /**
    * Get search data for all pages
@@ -26758,6 +27957,7 @@ var Website = class {
       if (page.isIndex && page.route.endsWith("/index")) return false;
       if (!includeHidden) {
         if (page.hidden) return false;
+        if (page.hideIn?.includes("*")) return false;
         if (navType && page.hideIn?.includes(navType)) return false;
       }
       if (!page.hasContent()) {
@@ -26795,6 +27995,41 @@ var Website = class {
     };
     return filteredPages.map(buildPageInfo);
   }
+  /**
+   * Get the page tree for the branch a route sits in.
+   *
+   * A sidebar shows one branch of a site, not the whole thing: under /docs it
+   * lists the documentation, and under a different top-level section it would
+   * list that instead. Every documentation shell built on this framework has
+   * hand-written the same narrowing, so it lives here — it is a question about
+   * the page graph, with no React and no DOM in it.
+   *
+   * Answers the branch's children when it has any, the branch itself when it
+   * is a leaf, and the whole hierarchy when the route matches no branch (the
+   * site root, most often). The pages come back in the order the build settled
+   * on; `pages:` lists are resolved at build time, so there is nothing to sort.
+   *
+   * @param {Object} [options]
+   * @param {string} options.route - The active route, e.g. '/docs/reference/cli'
+   * @param {string} [options.for] - Layout area being filled ('left', 'header', …).
+   *   Checked against each page's `hideIn`, so a page can sit out of this rail
+   *   while staying in the menu. Name the area the tree is actually for.
+   * @param {boolean} [options.includeHidden=false] - Include unpublished pages
+   * @returns {Array<Object>} Page info objects, nested
+   *
+   * @example
+   * // In a sidebar component rendered into the `left` layout area
+   * const pages = website.getBranchHierarchy({ route: location.pathname, for: 'left' })
+   */
+  getBranchHierarchy({ route = "", for: navType, includeHidden = false } = {}) {
+    const normalize = (value) => (value || "").replace(/^\/+/, "").replace(/\/+$/, "");
+    const all = this.getPageHierarchy({ for: navType, includeHidden });
+    const branchName = normalize(route).split("/")[0];
+    if (!branchName) return all;
+    const branch = all.find((page) => normalize(page.route) === branchName);
+    if (!branch) return all;
+    return branch.children?.length ? branch.children : [branch];
+  }
   /**
    * Get pages for header navigation
    * Convenience method equivalent to getPageHierarchy({ for: 'header' })
@@ -27361,9 +28596,9 @@ var Uniweb = class {
 };
 
 // ../core/src/theme.js
-var SHADE_LEVELS3 = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+var SHADE_LEVELS4 = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
 var VALID_CONTEXTS = ["light", "medium", "dark"];
-var DEFAULT_CONTEXT_TOKENS = {
+var DEFAULT_CONTEXT_TOKENS2 = {
   light: {
     bg: "var(--neutral-50)",
     text: "var(--neutral-950)",
@@ -27502,7 +28737,7 @@ var Theme = class {
     if (customContext && customContext[token]) {
       return customContext[token];
     }
-    const defaults = DEFAULT_CONTEXT_TOKENS[context];
+    const defaults = DEFAULT_CONTEXT_TOKENS2[context];
     return defaults?.[token] || null;
   }
   /**
@@ -27512,7 +28747,7 @@ var Theme = class {
    * @returns {Object} Token name → value mapping
    */
   getContextTokens(context) {
-    const defaults = DEFAULT_CONTEXT_TOKENS[context] || {};
+    const defaults = DEFAULT_CONTEXT_TOKENS2[context] || {};
     const custom = this._contexts[context] || {};
     return { ...defaults, ...custom };
   }
@@ -27621,7 +28856,8 @@ var Theme = class {
   /**
    * Get a specific font family
    *
-   * @param {string} type - Font type ('body', 'heading', 'mono')
+   * @param {string} type - Font role name ('body', 'heading', 'code', or a
+   *   foundation-defined role)
    * @returns {string|null} Font family string or null
    */
   getFont(type) {
@@ -27630,7 +28866,7 @@ var Theme = class {
   /**
    * Get CSS variable reference for a font
    *
-   * @param {string} type - Font type
+   * @param {string} type - Font role name
    * @returns {string} CSS var() reference
    */
   getFontVar(type) {
@@ -27680,7 +28916,7 @@ var Theme = class {
    * @returns {number[]}
    */
   getShadeLevels() {
-    return [...SHADE_LEVELS3];
+    return [...SHADE_LEVELS4];
   }
   /**
    * Check if theme has any custom configuration
@@ -27706,6 +28942,11 @@ var Theme = class {
     };
   }
 };
+function hasDarkScheme(appearance = {}) {
+  return Boolean(
+    appearance.allowToggle || appearance.default === "dark" || appearance.default === "system" || appearance.schemes?.includes("dark")
+  );
+}
 
 // ../core/src/where.js
 var OPERATORS = /* @__PURE__ */ new Set([
@@ -28184,6 +29425,16 @@ function createUniweb(content, foundation = null, extensions = [], { defaultFetc
 // dist/ssr.js
 var import_react = __toESM(require_react(), 1);
 var import_server = __toESM(require_server_browser(), 1);
+
+// ../core/src/section-id.js
+var PREFIX = "section-";
+function sectionDomId(section) {
+  if (!section) return `${PREFIX}unknown`;
+  const id = section.stableId || section.id;
+  return `${PREFIX}${id === void 0 || id === null || id === "" ? "unknown" : id}`;
+}
+
+// dist/ssr.js
 function guaranteeItemStructure(item) {
   return {
     title: item.title || "",
@@ -28442,7 +29693,7 @@ function wireFoundationCapabilities(uniweb, foundation) {
   }
 }
 function sliceContentForLocale(content, locale) {
-  const defaultLang = content?.config?.defaultLanguage || "en";
+  const defaultLang = resolveDefaultLocale(content?.config);
   const locData = content?.locales?.[locale];
   if (!locale || locale === defaultLang || !locData) return content;
   return {
@@ -28461,6 +29712,21 @@ function hydrateDataStore(website, fetchedData) {
     website.dataStore.set(deriveCacheKey(entry.config), { data: entry.data });
   }
 }
+function ensureThemeCss(uniweb, foundation) {
+  const website = uniweb?.activeWebsite;
+  const themeData = website?.themeData;
+  if (!themeData || themeData.css) return;
+  const caps = foundation?.default?.capabilities || {};
+  try {
+    const { config, css, links } = buildTheme(themeData, {
+      foundationVars: caps.vars || {},
+      base: website.basePath || "/"
+    });
+    Object.assign(themeData, config, { css, links });
+  } catch (err) {
+    console.warn("[uniweb] theme CSS generation failed:", err?.message || err);
+  }
+}
 var NS = "uw-";
 var toIdent = (name) => NS + String(name).replace(/[^a-zA-Z0-9_-]/g, "-");
 function resolveLayoutTransitions(areaNames, explicit) {
@@ -28469,6 +29735,46 @@ function resolveLayoutTransitions(areaNames, explicit) {
   for (const name of areaNames) transitions[name] = toIdent(name);
   return explicit ? { ...transitions, ...explicit } : transitions;
 }
+function applyBootScheme(respectSystem, fallback) {
+  var stored = null;
+  try {
+    stored = localStorage.getItem("uniweb-appearance");
+  } catch (e) {
+  }
+  var hasStored = stored === "light" || stored === "dark";
+  var scheme = hasStored ? stored : fallback;
+  if (!hasStored && respectSystem) {
+    try {
+      if (window.matchMedia("(prefers-color-scheme: dark)").matches) scheme = "dark";
+    } catch (e) {
+    }
+  }
+  try {
+    var root = document.documentElement;
+    if (scheme === "dark") {
+      root.classList.add("scheme-dark");
+      root.classList.remove("scheme-light");
+    } else {
+      root.classList.add("scheme-light");
+      root.classList.remove("scheme-dark");
+    }
+  } catch (e) {
+  }
+  return scheme;
+}
+function resolveAppearanceBoot(appearance) {
+  if (!appearance || !hasDarkScheme(appearance)) return null;
+  return {
+    respectSystem: appearance.respectSystemPreference !== false,
+    fallback: appearance.default === "dark" ? "dark" : "light"
+  };
+}
+function renderAppearanceBootScript(appearance) {
+  const opts = resolveAppearanceBoot(appearance);
+  if (!opts) return "";
+  const call = `(${applyBootScheme.toString()})(${opts.respectSystem}, ${JSON.stringify(opts.fallback)})`;
+  return `<script id="uniweb-appearance">${call}<\/script>`;
+}
 var VALID_CONTEXTS2 = ["light", "medium", "dark"];
 function getWrapperProps(block) {
   const theme = block.themeName;
@@ -28492,8 +29798,7 @@ function getWrapperProps(block) {
       style[`--${key}`] = value;
     }
   }
-  const sectionId = block.stableId || block.id;
-  return { id: `section-${sectionId}`, style, className, background };
+  return { id: sectionDomId(block), style, className, background };
 }
 function withOpacity(color, opacity) {
   if (color.startsWith("#")) {
@@ -28706,15 +30011,15 @@ function renderLayout(page, website) {
   return import_react.default.createElement(
     import_react.default.Fragment,
     null,
-    areaElements.header && import_react.default.createElement("header", null, areaElements.header),
+    areaElements.header && import_react.default.createElement("header", { style: { position: "relative", zIndex: 40 } }, areaElements.header),
     bodyElement && import_react.default.createElement("main", null, bodyElement),
-    areaElements.footer && import_react.default.createElement("footer", null, areaElements.footer)
+    areaElements.footer && import_react.default.createElement("footer", { style: { position: "relative", zIndex: 30 } }, areaElements.footer)
   );
 }
 function initPrerenderForLocale(content, foundation, locale, extensionsOrOptions, maybeOptions) {
   const localeContent = sliceContentForLocale(content, locale);
   const uniweb = initPrerender(localeContent, foundation, extensionsOrOptions, maybeOptions);
-  const defaultLang = content?.config?.defaultLanguage || "en";
+  const defaultLang = resolveDefaultLocale(content?.config);
   if (locale && locale !== defaultLang && uniweb.activeWebsite?.setActiveLocale) {
     uniweb.activeWebsite.setActiveLocale(locale);
   }
@@ -28747,6 +30052,7 @@ function initPrerender(content, foundation, extensionsOrOptions, maybeOptions) {
     );
   };
   wireFoundationCapabilities(uniweb, foundation);
+  ensureThemeCss(uniweb, foundation);
   const website = uniweb.activeWebsite;
   uniweb.routingComponents = {
     useLocation: () => {
@@ -28824,6 +30130,23 @@ function escapeHtml(str) {
 }
 function injectPageContent(html, renderedContent, page, options = {}) {
   let result = html;
+  if (!result.includes('id="uniweb-appearance"')) {
+    const bootScript = renderAppearanceBootScript(page?.website?.themeData?.appearance);
+    if (bootScript) {
+      result = result.replace("</head>", `  ${bootScript}
+</head>`);
+    }
+  }
+  const themeCss = page?.website?.themeData?.css;
+  if (themeCss && !result.includes('id="uniweb-theme"')) {
+    result = result.replace(
+      "</head>",
+      `  <style id="uniweb-theme">
+${themeCss}
+    </style>
+</head>`
+    );
+  }
   if (options.sectionOverrideCSS) {
     const overrideStyle = `<style id="uniweb-page-overrides">
 ${options.sectionOverrideCSS}
@@ -28851,6 +30174,26 @@ ${options.sectionOverrideCSS}
 </head>`);
     }
   }
+  const headMeta = page.getHeadMeta?.();
+  if (headMeta) {
+    const og = headMeta.og || {};
+    const keywords = Array.isArray(headMeta.keywords) ? headMeta.keywords.join(", ") : headMeta.keywords;
+    const tags = [];
+    if (keywords) tags.push(`<meta name="keywords" content="${escapeHtml(keywords)}">`);
+    if (headMeta.robots) tags.push(`<meta name="robots" content="${escapeHtml(headMeta.robots)}">`);
+    if (og.title) tags.push(`<meta property="og:title" content="${escapeHtml(og.title)}">`);
+    if (og.description) tags.push(`<meta property="og:description" content="${escapeHtml(og.description)}">`);
+    if (og.image) tags.push(`<meta property="og:image" content="${escapeHtml(og.image)}">`);
+    if (og.url) tags.push(`<meta property="og:url" content="${escapeHtml(og.url)}">`);
+    tags.push('<meta property="og:type" content="website">');
+    tags.push(`<meta name="twitter:card" content="${og.image ? "summary_large_image" : "summary"}">`);
+    if (og.title) tags.push(`<meta name="twitter:title" content="${escapeHtml(og.title)}">`);
+    if (og.description) tags.push(`<meta name="twitter:description" content="${escapeHtml(og.description)}">`);
+    if (og.image) tags.push(`<meta name="twitter:image" content="${escapeHtml(og.image)}">`);
+    if (headMeta.canonical) tags.push(`<link rel="canonical" href="${escapeHtml(headMeta.canonical)}">`);
+    if (tags.length) result = result.replace("</head>", `${tags.join("\n")}
+</head>`);
+  }
   return result;
 }
 function generate404Html({ baseHtml, website, siteContent }) {
@@ -28885,8 +30228,9 @@ function generate404Html({ baseHtml, website, siteContent }) {
 }
 
 // dist/worker-runtime-entry.js
-globalThis.__PLATFORM_REACT = __PlatformReact;
-globalThis.__PLATFORM_JSX_RUNTIME = __PlatformJsxRuntime;
+globalThis.__PLATFORM_REACT = __P0;
+globalThis.__PLATFORM_REACT_DOM = __P1;
+globalThis.__PLATFORM_JSX_RUNTIME = __P2;
 globalThis.__PLATFORM_UNIWEB_CORE = src_exports;
 export {
   applyDefaults,
@@ -28904,6 +30248,7 @@ export {
   injectPageContent,
   prefetchIcons,
   prepareProps,
+  renderAppearanceBootScript,
   renderBackground,
   renderBlock,
   renderBlocks,
@@ -28924,10 +30269,10 @@ react/cjs/react.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 
-react/cjs/react-jsx-runtime.development.js:
+react-dom/cjs/react-dom.development.js:
   (**
    * @license React
-   * react-jsx-runtime.development.js
+   * react-dom.development.js
    *
    * Copyright (c) Meta Platforms, Inc. and affiliates.
    *
@@ -28935,10 +30280,10 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 
-react-dom/cjs/react-dom.development.js:
+react/cjs/react-jsx-runtime.development.js:
   (**
    * @license React
-   * react-dom.development.js
+   * react-jsx-runtime.development.js
    *
    * Copyright (c) Meta Platforms, Inc. and affiliates.
    *