@fayz-ai/storefront 0.80.0 → 0.82.0

package/dist/chunk-GI5BTJK6.js

@@ -0,0 +1,1336 @@
+import { STOREFRONT_SLOTS, registerStorefrontBlocks, THEME_SCALE_FIELDS, THEME_SCALE_VAR_PREFIX } from './chunk-RYWQGQ4M.js';
+import { toBlockNodes, routePathParams } from './chunk-UJHCVRK3.js';
+import { listEntityDeclarations, resolveHandle, errorMessage, RESERVED_ENTITY_FIELDS, ENTITY_FIELD_TYPES, handleNameFor, registerHandle, checkBlockConstraints, hasHandle, listHandles, blockRegistry, getBlockMeta, loaderRegistry, listLoaders, isLoaderParamRef, isLoaderPropRef } from '@fayz-ai/core';
+import { PROMOTION_TYPES, PROMOTION_STATUSES, APPLICATION_METHOD_TYPES, APPLICATION_METHOD_TARGET_TYPES, APPLICATION_METHOD_ALLOCATIONS, hasRuleAttribute, listRuleAttributeKeys, RULE_OPERATORS, resolveRuleAttribute } from '@fayz-ai/shop/rules';
+
+// src/document/sections.ts
+var STORE_DOCUMENT_KIND = "fayz.store";
+var STORE_COMMERCE_MODES = ["checkout", "catalog", "enquiry", "delivery"];
+var STORE_PAYMENT_MODES = ["mock", "pix-mercadopago", "gateway"];
+var STORE_PAYMENT_METHOD_KINDS = [
+  "pix",
+  "credit_card",
+  "debit_card",
+  "boleto",
+  "cash",
+  "other"
+];
+var STORE_BACKEND_PROVIDERS = ["mock", "fayz-api", "fayz-shop", "custom"];
+var STORE_ROUTE_KINDS = [
+  "home",
+  "catalog",
+  "product",
+  "checkout",
+  "account",
+  "order",
+  "custom"
+];
+var STORE_ROUTE_CHROMES = ["default", "minimal", "focused"];
+var STORE_THEME_RADII = ["none", "soft", "round", "pill"];
+var f = (type, description, extra = {}) => ({ type, description, ...extra });
+var STORE_SECTIONS = {
+  store: {
+    description: "Store identity: name, currency, locale.",
+    versions: [1],
+    fields: {
+      name: f("string", "Store display name (header, page title).", { required: true }),
+      currency: f("string", "ISO 4217 currency code \u2014 default 'BRL'."),
+      locale: f("string", "Intl locale for money/date formatting \u2014 default 'pt-BR'.")
+    }
+  },
+  theme: {
+    description: "Visual identity: colors, fonts, radius, header/card personality.",
+    versions: [1],
+    fields: {
+      name: f("string", "Theme name.", { required: true }),
+      colors: f("object", "HSL token triplets (background, primary, \u2026)."),
+      font: f("object", "Google Fonts pairing (heading, body, display, serif)."),
+      radius: f("string", "Corner radius scale.", { enum: STORE_THEME_RADII }),
+      header: f("object", "Header treatment (variant, uppercaseNav, search)."),
+      productCard: f("object", "Card style and image aspect."),
+      uppercaseButtons: f("boolean", "Uppercase CTA buttons with letter-spacing."),
+      spacing: f("object", "Spacing scale (key \u2192 CSS length), emitted as --sf-space-<key>. e.g. {sm:'8px', md:'16px'}."),
+      typeScale: f("object", "Type scale (key \u2192 CSS font-size), emitted as --sf-text-<key>. e.g. {body:'1rem', h1:'clamp(40px,6vw,66px)'}."),
+      breakpoints: f("object", "Layout breakpoints (key \u2192 CSS length), emitted as --sf-breakpoint-<key> for JS/generated-style consumers."),
+      motion: f("object", "Motion tokens (key \u2192 duration or easing), emitted as --sf-motion-<key>. e.g. {fast:'150ms', reveal:'cubic-bezier(0.22,1,0.36,1)'}."),
+      tokens: f("object", "Free-form brand-token passthrough, emitted verbatim as CSS custom properties.")
+    }
+  },
+  commerce: {
+    description: "Commercial behavior: mode, shipping, payments, discounts, enquiry, feature toggles.",
+    // v2 = the legacy `discounts` coupon list has been migrated onto the rule
+    // engine (codemod commerce.discounts-to-promotions). Both versions are
+    // understood, which is the whole point: the fleet migrates store by store.
+    versions: [1, 2],
+    fields: {
+      commerceMode: f("string", "Checkout-first, catalog-only browsing, or product enquiry.", {
+        enum: STORE_COMMERCE_MODES
+      }),
+      shipping: f("object", "Flat rate and free-above threshold."),
+      payments: f("object", "Payment mode and offered methods."),
+      discounts: f("array", "DEPRECATED \u2014 store-level discount codes ({code, percent, title?}). Use promotions.promotions.", {
+        deprecated: {
+          id: "storefront.commerce.discounts",
+          removedAtVersion: 2,
+          replacement: "promotions.promotions"
+        }
+      }),
+      enquiry: f("object", "Product enquiry behavior for catalog/enquiry stores."),
+      features: f("object", "Feature toggles (discounts, accounts, cart, checkout).")
+    }
+  },
+  presentation: {
+    description: "What the shopper sees: composed pages, slots, nav, footer, chrome.",
+    versions: [1],
+    fields: {
+      announcement: f("string", "Promo message above the header."),
+      logo: f("string", "Text logo. A JSX logo is code and lives at code.logo."),
+      home: f("object", "Home page blueprint (legacy short form of pages.home)."),
+      pages: f("object", "Pages composed from blocks, keyed by page kind."),
+      slots: f("object", "Blocks grafted into named positions inside SDK pages."),
+      nav: f("array", "Header nav links ({label, to})."),
+      footer: f("object", "Footer content (about, contact, social, labels)."),
+      imageLoading: f("object", "Global image reveal behavior."),
+      catalogFacets: f(
+        "array",
+        "Catalog refinements over product.metadata ({key, label, values[]}), rendered in the filters panel and mirrored into ?<key>=<value>."
+      ),
+      productSpecs: f(
+        "object",
+        "PDP specification table rules: `exclude` hides metadata keys, `labels` renames the rest."
+      ),
+      search: f(
+        "object",
+        "Header search: mode ('inline' live filter, the default, or 'overlay'), plus placeholder, resultsPath, suggestionsLimit, minChars and labels. A custom suggestion renderer is code and lives at code.searchRenderSuggestion."
+      )
+    }
+  },
+  content: {
+    description: "Long-form content: legal/institutional pages, product reviews.",
+    versions: [1],
+    fields: {
+      legal: f("object", "Privacy / terms / returns page text."),
+      reviews: f(
+        "object",
+        "Store-supplied product reviews ({items, enabled, emptyText}). Nothing is invented \u2014 with no items the PDP renders an honest empty state."
+      )
+    }
+  },
+  catalog: {
+    description: "Mock catalog seed for stores without a live backend.",
+    versions: [1],
+    fields: {
+      products: f("array", "Seed products."),
+      categories: f("array", "Seed categories."),
+      discounts: f("array", "Seed discounts."),
+      promotions: f("array", "Seed rule-engine promotions for the mock provider. Prefer the top-level promotions section.")
+    }
+  },
+  entities: {
+    description: "Custom entity declarations (defineEntity inputs), keyed by entity key.",
+    versions: [1],
+    fields: {
+      definitions: f("object", "Entity key \u2192 declaration ({fields, scope, access, indexes, \u2026}).")
+    }
+  },
+  promotions: {
+    description: "Rule-engine promotions: eligibility rules + application method, as pure data (spine M6).",
+    versions: [1],
+    fields: {
+      promotions: f("array", "Promotions ({id, code?, isAutomatic?, rules?, applicationMethod}). Rule attributes come from the rule_attribute vocabulary.")
+    }
+  },
+  backend: {
+    description: "Backend descriptor: which provider serves the store.",
+    // v2 = the legacy supabaseUrl/supabaseAnonKey pair has moved to
+    // auth.supabase (codemod backend.supabase-to-auth).
+    versions: [1, 2],
+    fields: {
+      provider: f("string", "Backend provider family.", { enum: STORE_BACKEND_PROVIDERS }),
+      url: f("string", "Backend URL, when the provider needs one."),
+      supabaseUrl: f("string", "DEPRECATED legacy field, kept for lossless round-trip. Use auth.supabase.url.", {
+        deprecated: {
+          id: "storefront.backend.supabaseUrl",
+          removedAtVersion: 2,
+          replacement: "auth.supabase.url"
+        }
+      }),
+      supabaseAnonKey: f("string", "DEPRECATED legacy field, kept for lossless round-trip. Use auth.supabase.anonKey.", {
+        deprecated: {
+          id: "storefront.backend.supabaseAnonKey",
+          removedAtVersion: 2,
+          replacement: "auth.supabase.anonKey"
+        }
+      })
+    }
+  },
+  auth: {
+    description: "Customer auth, when expressible as data. Code-bearing auth lives at code.auth.",
+    versions: [1],
+    fields: {
+      adapter: f("string", "Adapter id ('mock' | 'supabase')."),
+      provider: f("string", "Provider id ('mock' | 'supabase')."),
+      routes: f("object", "Auth route overrides."),
+      supabase: f("object", "Supabase connection (url, anonKey, callback urls).")
+    }
+  },
+  code: {
+    description: "The code sidecar: config fields that hold code, referenced by registered handle name.",
+    versions: [1],
+    fields: {
+      logo: f("string", "Handle of the JSX logo node."),
+      provider: f("string", "Handle of the explicit ShopProvider."),
+      auth: f("string", "Handle of a code-bearing auth config."),
+      footerCredit: f("string", "Handle of the footer credit node."),
+      searchRenderSuggestion: f("string", "Handle of the custom search-suggestion renderer."),
+      components: f("object", "Component-slot name \u2192 handle of its override."),
+      routes: f("array", "Custom routes; each component is a handle name.")
+    }
+  }
+};
+var STORE_SECTION_NAMES = Object.keys(STORE_SECTIONS);
+function sectionToJsonSchema(name) {
+  const spec = STORE_SECTIONS[name];
+  const properties = {
+    version: {
+      type: "integer",
+      description: `Schema version of the ${name} section. Supported: ${spec.versions.join(", ")}.`,
+      enum: [...spec.versions]
+    }
+  };
+  const required = ["version"];
+  for (const [field, fieldSpec] of Object.entries(spec.fields)) {
+    const node = { type: fieldSpec.type, description: fieldSpec.description };
+    if (fieldSpec.enum) node.enum = [...fieldSpec.enum];
+    if (fieldSpec.deprecated) {
+      node.deprecated = true;
+      node["x-fayz-deprecation"] = fieldSpec.deprecated.id;
+      node["x-fayz-replacement"] = fieldSpec.deprecated.replacement;
+      node["x-fayz-removed-at-section-version"] = fieldSpec.deprecated.removedAtVersion;
+    }
+    properties[field] = node;
+    if (fieldSpec.required) required.push(field);
+  }
+  return {
+    type: "object",
+    description: spec.description,
+    properties,
+    required
+  };
+}
+function isJsonValue(value) {
+  if (value === null) return true;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean") return true;
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (t === "object") {
+    const record = value;
+    if ("$$typeof" in record) return false;
+    const proto = Object.getPrototypeOf(record);
+    if (proto !== Object.prototype && proto !== null) return false;
+    return Object.values(record).every((v) => v === void 0 || isJsonValue(v));
+  }
+  return false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compact(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+
+// src/extend/component-contracts.ts
+var STOREFRONT_COMPONENT_KEYS = [
+  "ProductCard",
+  "ProductDetail",
+  "ProductGallery",
+  "ProductPrice",
+  "ProductActions",
+  "ProductEnquiryForm",
+  "CategoryCard",
+  "CollectionSection",
+  "HeroSection",
+  "MediaCarousel",
+  "ProductSlider",
+  "Header",
+  "Footer",
+  "Shell",
+  "EmptyState",
+  "LoadingState",
+  "ErrorState",
+  "CartDrawerFooterExtra"
+];
+var STOREFRONT_PAGE_KINDS = ["home", "catalog", "product", "collection", "content"];
+var STRUCTURAL_BLOCK_KEYS = /* @__PURE__ */ new Set(["type", "id", "props", "children", "data"]);
+var DATA_NEED_KEYS = ["loader", "params"];
+var CODE_ROUTE_KEYS = ["id", "path", "kind", "chrome", "component"];
+var SLOT_AREAS = [...new Set(STOREFRONT_SLOTS.map((slot) => slot.area))];
+function slotNamesFor(area) {
+  return STOREFRONT_SLOTS.filter((slot) => slot.area === area).map((slot) => slot.name);
+}
+var PAGE_KIND_PARAMS = {
+  home: [],
+  catalog: [],
+  product: ["slug"],
+  collection: ["slug"]
+};
+var SLOT_AREA_PARAMS = {
+  productDetail: ["slug"]
+};
+var knownEntities = /* @__PURE__ */ new Set();
+function checkEntityRef(errors, path, value) {
+  if (typeof value !== "string" || !value) return;
+  if (!knownEntities.has(value)) {
+    push(
+      errors,
+      path,
+      "unknown-entity",
+      `entity "${value}" is not declared (defineEntity or the entities section)`,
+      [...knownEntities].sort()
+    );
+  }
+}
+function push(errors, path, code, message, valid) {
+  errors.push(valid ? { path, code, message, valid: [...valid] } : { path, code, message });
+}
+function blockPropKeys(entry) {
+  if ("props" in entry) {
+    const props = entry.props;
+    return isRecord(props) ? Object.keys(props) : [];
+  }
+  return Object.keys(entry).filter((key) => !STRUCTURAL_BLOCK_KEYS.has(key));
+}
+function validateSettingValues(errors, valuesPath, settings, values, owner, labelPrefix = "") {
+  for (const setting of settings) {
+    const value = values[setting.id];
+    if (value === void 0) continue;
+    const valuePath = `${valuesPath}.${setting.id}`;
+    const label = `${labelPrefix}${setting.id}`;
+    if (setting.type === "entity") {
+      checkEntityRef(errors, valuePath, value);
+      continue;
+    }
+    if (setting.type !== "list" || !setting.of?.length || !Array.isArray(value)) continue;
+    const of = setting.of;
+    const declared = collectSettingIds(of);
+    value.forEach((item, index) => {
+      if (!isRecord(item)) return;
+      const itemPath = `${valuePath}[${index}]`;
+      for (const key of Object.keys(item)) {
+        if (!declared.has(key)) {
+          push(
+            errors,
+            `${itemPath}.${key}`,
+            owner.code,
+            `${owner.subject} declares no ${owner.noun} "${label}[].${key}"`,
+            [...declared].sort()
+          );
+        }
+      }
+      validateSettingValues(errors, itemPath, of, item, owner, `${label}[].`);
+    });
+  }
+}
+function checkLiteralParam(errors, path, containerPath, loaderId, setting, value) {
+  const expected = setting.type === "number" ? "number" : setting.type === "boolean" ? "boolean" : setting.type === "list" ? "array" : "string";
+  const actual = Array.isArray(value) ? "array" : typeof value;
+  if (actual !== expected) {
+    push(
+      errors,
+      path,
+      "invalid-value",
+      `loader "${loaderId}" param "${setting.id}" expects ${expected}, got ${actual}`
+    );
+    return;
+  }
+  if (setting.type === "select" && setting.options?.length && typeof value === "string") {
+    const allowed = setting.options.map((option) => option.value);
+    if (!allowed.includes(value)) {
+      push(errors, path, "invalid-value", `"${value}" is not a valid ${setting.id}`, allowed);
+    }
+  }
+  if (setting.type === "entity") checkEntityRef(errors, path, value);
+  if (setting.type === "list") {
+    validateSettingValues(
+      errors,
+      containerPath,
+      [setting],
+      { [setting.id]: value },
+      { subject: `loader "${loaderId}"`, noun: "param", code: "unknown-loader-param" }
+    );
+  }
+}
+function validateDataNeeds(errors, entryPath, blockType, value, declaredParams) {
+  if (!isRecord(value)) {
+    push(errors, `${entryPath}.data`, "invalid-value", "`data` maps need names to {loader, params?}");
+    return;
+  }
+  const blockSettings = getBlockMeta(blockType)?.settings;
+  for (const [name, need] of Object.entries(value)) {
+    const needPath = `${entryPath}.data.${name}`;
+    if (!isRecord(need) || typeof need.loader !== "string" || !need.loader) {
+      push(errors, needPath, "invalid-value", "a data need is {loader: string, params?: object}");
+      continue;
+    }
+    if (!loaderRegistry.has(need.loader)) {
+      push(errors, `${needPath}.loader`, "unknown-loader", `loader "${need.loader}" is not registered`, listLoaders());
+      continue;
+    }
+    for (const key of Object.keys(need)) {
+      if (!DATA_NEED_KEYS.includes(key)) {
+        push(errors, `${needPath}.${key}`, "unknown-field", `a data need has no field "${key}"`, DATA_NEED_KEYS);
+      }
+    }
+    if (need.params === void 0) continue;
+    if (!isRecord(need.params)) {
+      push(errors, `${needPath}.params`, "invalid-value", "loader params are an object");
+      continue;
+    }
+    const loaderSettings = loaderRegistry.getEntry(need.loader)?.meta.settings;
+    const declaredLoaderParams = loaderSettings ? collectSettingIds(loaderSettings) : null;
+    for (const [param, paramValue] of Object.entries(need.params)) {
+      const paramPath = `${needPath}.params.${param}`;
+      const setting = loaderSettings?.find((s) => s.id === param);
+      if (declaredLoaderParams && !declaredLoaderParams.has(param)) {
+        push(
+          errors,
+          paramPath,
+          "unknown-loader-param",
+          `loader "${need.loader}" declares no param "${param}"`,
+          [...declaredLoaderParams].sort()
+        );
+        continue;
+      }
+      if (isLoaderParamRef(paramValue)) {
+        if (!declaredParams.includes(paramValue.$param)) {
+          push(
+            errors,
+            paramPath,
+            "unbound-route-param",
+            declaredParams.length ? `$param "${paramValue.$param}" is not a route param of this page` : `$param "${paramValue.$param}" cannot bind \u2014 this page declares no route params`,
+            declaredParams
+          );
+        }
+        continue;
+      }
+      if (isLoaderPropRef(paramValue)) {
+        const settingIds = blockSettings ? collectSettingIds(blockSettings) : null;
+        if (settingIds && !settingIds.has(paramValue.$prop)) {
+          push(
+            errors,
+            paramPath,
+            "unknown-prop-binding",
+            `$prop "${paramValue.$prop}" is not a setting of block "${blockType}"`,
+            [...settingIds].sort()
+          );
+        }
+        continue;
+      }
+      if (setting) {
+        checkLiteralParam(errors, paramPath, `${needPath}.params`, need.loader, setting, paramValue);
+      }
+    }
+  }
+}
+function validateBlockList(errors, path, value, declaredParams) {
+  if (!Array.isArray(value)) {
+    push(errors, path, "invalid-value", `expected an array of blocks, got ${typeof value}`);
+    return;
+  }
+  value.forEach((entry, index) => {
+    const entryPath = `${path}[${index}]`;
+    if (!isRecord(entry)) {
+      push(errors, entryPath, "invalid-value", "a block entry must be an object with a `type`");
+      return;
+    }
+    const type = entry.type;
+    if (typeof type !== "string" || !type) {
+      push(errors, `${entryPath}.type`, "invalid-value", "a block entry must declare a string `type`");
+      return;
+    }
+    if (!blockRegistry.has(type)) {
+      push(
+        errors,
+        `${entryPath}.type`,
+        "unknown-block",
+        `block "${type}" is not registered`,
+        blockRegistry.ids().sort()
+      );
+      return;
+    }
+    const settings = getBlockMeta(type)?.settings;
+    if (settings) {
+      const declared = collectSettingIds(settings);
+      for (const key of blockPropKeys(entry)) {
+        if (!declared.has(key)) {
+          push(
+            errors,
+            `${entryPath}.props.${key}`,
+            "unknown-setting",
+            `block "${type}" declares no setting "${key}"`,
+            [...declared].sort()
+          );
+        }
+      }
+      const props = isRecord(entry.props) ? entry.props : entry;
+      validateSettingValues(errors, `${entryPath}.props`, settings, props, {
+        subject: `block "${type}"`,
+        noun: "setting",
+        code: "unknown-setting"
+      });
+    }
+    if ("data" in entry && entry.data !== void 0) {
+      validateDataNeeds(errors, entryPath, type, entry.data, declaredParams);
+    }
+    if ("children" in entry && entry.children !== void 0) {
+      validateBlockList(errors, `${entryPath}.children`, entry.children, declaredParams);
+    }
+  });
+}
+function validateBlockTree(errors, path, value, declaredParams = []) {
+  validateBlockList(errors, path, value, declaredParams);
+  if (!Array.isArray(value)) return;
+  const nodes = toBlockNodes(value);
+  for (const violation of checkBlockConstraints(nodes)) {
+    push(errors, `${path}${violation.path}`, violation.rule, violation.detail, violation.valid);
+  }
+}
+function collectSettingIds(settings) {
+  return new Set(settings.map((setting) => setting.id));
+}
+var TOKEN_KEY = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+function validateTheme(errors, section) {
+  for (const field of THEME_SCALE_FIELDS) {
+    const scale = section[field];
+    if (scale === void 0) continue;
+    if (!isRecord(scale)) continue;
+    for (const [key, value] of Object.entries(scale)) {
+      const path = `theme.${field}.${key}`;
+      if (!TOKEN_KEY.test(key)) {
+        push(
+          errors,
+          path,
+          "invalid-token-key",
+          `"${key}" cannot become the CSS custom property ${THEME_SCALE_VAR_PREFIX[field]}-${key} \u2014 token keys match ${TOKEN_KEY}`
+        );
+      }
+      if (typeof value !== "string") {
+        push(errors, path, "invalid-value", `a ${field} token is a CSS value string, got ${typeof value}`);
+      }
+    }
+  }
+}
+function validateSectionEnvelope(errors, name, section) {
+  const spec = STORE_SECTIONS[name];
+  const version = section.version;
+  if (typeof version !== "number" || !spec.versions.includes(version)) {
+    push(
+      errors,
+      `${name}.version`,
+      "unsupported-section-version",
+      `section "${name}" declares version ${JSON.stringify(version)}, which this SDK does not understand`,
+      spec.versions.map(String)
+    );
+    return false;
+  }
+  const fieldNames = Object.keys(spec.fields);
+  for (const key of Object.keys(section)) {
+    if (key === "version") continue;
+    const fieldSpec = spec.fields[key];
+    if (!fieldSpec) {
+      push(errors, `${name}.${key}`, "unknown-field", `section "${name}" has no field "${key}"`, fieldNames);
+      continue;
+    }
+    const deprecated = fieldSpec.deprecated;
+    if (deprecated && version >= deprecated.removedAtVersion) {
+      push(
+        errors,
+        `${name}.${key}`,
+        "removed-field",
+        `field "${name}.${key}" was removed at ${name} version ${deprecated.removedAtVersion} (deprecation ${deprecated.id}); this section declares version ${version}`,
+        [deprecated.replacement]
+      );
+      continue;
+    }
+    const value = section[key];
+    const actual = Array.isArray(value) ? "array" : typeof value;
+    if (actual !== fieldSpec.type) {
+      push(
+        errors,
+        `${name}.${key}`,
+        "invalid-value",
+        `field "${name}.${key}" expects ${fieldSpec.type}, got ${actual}`
+      );
+      continue;
+    }
+    if (fieldSpec.enum && typeof value === "string" && !fieldSpec.enum.includes(value)) {
+      push(
+        errors,
+        `${name}.${key}`,
+        "invalid-value",
+        `"${value}" is not a valid ${name}.${key}`,
+        fieldSpec.enum
+      );
+    }
+  }
+  for (const [field, fieldSpec] of Object.entries(spec.fields)) {
+    if (fieldSpec.required && section[field] === void 0) {
+      push(errors, `${name}.${field}`, "missing-field", `section "${name}" requires "${field}"`);
+    }
+  }
+  return true;
+}
+function validateCommerce(errors, section) {
+  const payments = section.payments;
+  if (isRecord(payments)) {
+    if (payments.mode !== void 0) {
+      if (typeof payments.mode !== "string" || !STORE_PAYMENT_MODES.includes(payments.mode)) {
+        push(
+          errors,
+          "commerce.payments.mode",
+          "invalid-value",
+          `"${String(payments.mode)}" is not a payment mode`,
+          STORE_PAYMENT_MODES
+        );
+      }
+    }
+    if (payments.methods !== void 0) {
+      if (!Array.isArray(payments.methods)) {
+        push(errors, "commerce.payments.methods", "invalid-value", "payments.methods must be an array");
+      } else {
+        payments.methods.forEach((method, index) => {
+          if (typeof method !== "string" || !STORE_PAYMENT_METHOD_KINDS.includes(method)) {
+            push(
+              errors,
+              `commerce.payments.methods[${index}]`,
+              "invalid-value",
+              `"${String(method)}" is not a payment method`,
+              STORE_PAYMENT_METHOD_KINDS
+            );
+          }
+        });
+      }
+    }
+  }
+  const discounts = section.discounts;
+  if (Array.isArray(discounts)) {
+    discounts.forEach((discount, index) => {
+      if (!isRecord(discount) || typeof discount.code !== "string" || typeof discount.percent !== "number") {
+        push(
+          errors,
+          `commerce.discounts[${index}]`,
+          "invalid-value",
+          "a discount is {code: string, percent: number, title?: string}"
+        );
+      }
+    });
+  }
+}
+var CONTENT_SLUG = /^[a-z0-9][a-z0-9-]*$/;
+function validateContentPages(errors, basePath, value) {
+  if (!isRecord(value)) {
+    push(errors, basePath, "invalid-value", "pages.content maps slugs to {title?, path?, blocks: [...]}");
+    return;
+  }
+  const pathOwners = /* @__PURE__ */ new Map();
+  for (const [slug, page] of Object.entries(value)) {
+    const pagePath = `${basePath}.${slug}`;
+    if (!CONTENT_SLUG.test(slug)) {
+      push(
+        errors,
+        pagePath,
+        "invalid-value",
+        `"${slug}" cannot become the route "/${slug}" \u2014 content slugs match ${CONTENT_SLUG}`
+      );
+    }
+    if (!isRecord(page) || page.blocks === void 0) {
+      push(errors, pagePath, "invalid-value", "a content page is {title?, path?, blocks: [...]}");
+      continue;
+    }
+    if (page.title !== void 0 && typeof page.title !== "string") {
+      push(errors, `${pagePath}.title`, "invalid-value", `title expects string, got ${typeof page.title}`);
+    }
+    let routePath = `/${slug}`;
+    if (page.path !== void 0) {
+      if (typeof page.path !== "string" || !page.path.startsWith("/")) {
+        push(errors, `${pagePath}.path`, "invalid-value", `path is an absolute route ('/${slug}'), got ${JSON.stringify(page.path)}`);
+      } else {
+        routePath = page.path;
+      }
+    }
+    const owner = pathOwners.get(routePath);
+    if (owner) {
+      push(
+        errors,
+        `${pagePath}.path`,
+        "duplicate-content-path",
+        `content pages "${owner}" and "${slug}" both resolve to "${routePath}" \u2014 one of them can never render`
+      );
+    } else {
+      pathOwners.set(routePath, slug);
+    }
+    validateBlockTree(errors, `${pagePath}.blocks`, page.blocks, routePathParams(routePath));
+  }
+}
+function validatePresentation(errors, section) {
+  const home = section.home;
+  if (isRecord(home) && home.sections !== void 0) {
+    validateBlockTree(errors, "presentation.home.sections", home.sections);
+  }
+  const pages = section.pages;
+  if (isRecord(pages)) {
+    const validKinds = [...STOREFRONT_PAGE_KINDS];
+    for (const [kind, page] of Object.entries(pages)) {
+      const pagePath = `presentation.pages.${kind}`;
+      if (!validKinds.includes(kind)) {
+        push(errors, pagePath, "unknown-page-kind", `"${kind}" is not a composable page kind`, validKinds);
+        continue;
+      }
+      if (kind === "content") {
+        validateContentPages(errors, pagePath, page);
+        continue;
+      }
+      if (!isRecord(page) || page.blocks === void 0) {
+        push(errors, pagePath, "invalid-value", "a composed page is {blocks: [...]}");
+        continue;
+      }
+      validateBlockTree(errors, `${pagePath}.blocks`, page.blocks, PAGE_KIND_PARAMS[kind] ?? []);
+    }
+  }
+  const slots = section.slots;
+  if (isRecord(slots)) {
+    for (const [area, areaSlots] of Object.entries(slots)) {
+      const areaPath = `presentation.slots.${area}`;
+      if (!SLOT_AREAS.includes(area)) {
+        push(errors, areaPath, "unknown-slot-area", `"${area}" is not a slot area`, SLOT_AREAS);
+        continue;
+      }
+      if (!isRecord(areaSlots)) {
+        push(errors, areaPath, "invalid-value", "a slot area maps slot names to block lists");
+        continue;
+      }
+      const validNames = slotNamesFor(area);
+      for (const [slotName, blocks] of Object.entries(areaSlots)) {
+        const slotPath = `${areaPath}.${slotName}`;
+        if (!validNames.includes(slotName)) {
+          push(errors, slotPath, "unknown-slot", `"${area}.${slotName}" is not a slot`, validNames);
+          continue;
+        }
+        validateBlockTree(errors, slotPath, blocks, SLOT_AREA_PARAMS[area] ?? []);
+      }
+    }
+  }
+}
+var ENTITY_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var ENTITY_FIELD_RE = /^[a-z][a-z0-9_]*$/;
+function validateEntitiesSection(errors, section) {
+  const definitions = section.definitions;
+  if (definitions === void 0 || !isRecord(definitions)) return;
+  for (const [key, declaration] of Object.entries(definitions)) {
+    const path = `entities.definitions.${key}`;
+    if (!ENTITY_KEY_RE.test(key)) {
+      push(errors, path, "invalid-value", `"${key}" is not a valid entity key \u2014 keys are snake_case`);
+    }
+    if (!isRecord(declaration) || !isRecord(declaration.fields) || Object.keys(declaration.fields).length === 0) {
+      push(errors, path, "invalid-value", "an entity declaration is {fields: {<name>: {type, \u2026}}, scope?, access?, indexes?}");
+      continue;
+    }
+    const fields = declaration.fields;
+    const fieldNames = Object.keys(fields);
+    for (const [name, field] of Object.entries(fields)) {
+      const fieldPath = `${path}.fields.${name}`;
+      if (!ENTITY_FIELD_RE.test(name)) {
+        push(errors, fieldPath, "invalid-value", `"${name}" is not a valid field name \u2014 fields are snake_case`);
+      }
+      if (RESERVED_ENTITY_FIELDS.includes(name)) {
+        push(errors, fieldPath, "invalid-value", `"${name}" is a structural record column`, RESERVED_ENTITY_FIELDS);
+        continue;
+      }
+      if (!isRecord(field) || typeof field.type !== "string") {
+        push(errors, fieldPath, "invalid-value", "a field is {type: <entity field type>, label?, required?, \u2026}");
+        continue;
+      }
+      if (!ENTITY_FIELD_TYPES.includes(field.type)) {
+        push(errors, `${fieldPath}.type`, "unknown-entity-field-type", `"${field.type}" is not an entity field type`, ENTITY_FIELD_TYPES);
+        continue;
+      }
+      if (field.type === "ref") {
+        if (typeof field.entity !== "string" || !field.entity) {
+          push(errors, fieldPath, "invalid-value", `a ref field names its target: {type: 'ref', entity: '<key>'}`);
+        } else {
+          checkEntityRef(errors, `${fieldPath}.entity`, field.entity);
+        }
+      }
+    }
+    const scope = declaration.scope;
+    if (scope !== void 0 && scope !== "tenant") {
+      push(errors, `${path}.scope`, "invalid-value", `"${String(scope)}" is not an entity scope`, ["tenant"]);
+    }
+    const access = declaration.access;
+    if (access !== void 0) {
+      if (!isRecord(access)) {
+        push(errors, `${path}.access`, "invalid-value", "access is {read: 'public'|'staff', write: 'staff'}");
+      } else {
+        if (access.read !== void 0 && access.read !== "public" && access.read !== "staff") {
+          push(errors, `${path}.access.read`, "invalid-value", `"${String(access.read)}" is not a read access level`, ["public", "staff"]);
+        }
+        if (access.write !== void 0 && access.write !== "staff") {
+          push(errors, `${path}.access.write`, "invalid-value", `"${String(access.write)}" is not a write access level \u2014 shopper writes go through actions (M7), not RLS`, ["staff"]);
+        }
+      }
+    }
+    const references = (where, name) => {
+      if (typeof name !== "string" || !fieldNames.includes(name)) {
+        push(errors, `${path}.${where}`, "invalid-value", `${where} references undeclared field "${String(name)}"`, fieldNames);
+      }
+    };
+    if (Array.isArray(declaration.indexes)) {
+      declaration.indexes.forEach((tuple, i) => {
+        if (!Array.isArray(tuple)) {
+          push(errors, `${path}.indexes[${i}]`, "invalid-value", "an index is an array of declared field names");
+          return;
+        }
+        for (const name of tuple) references(`indexes[${i}]`, name);
+      });
+    }
+    if (declaration.titleField !== void 0) references("titleField", declaration.titleField);
+    if (Array.isArray(declaration.displayFields)) {
+      for (const name of declaration.displayFields) references("displayFields", name);
+    }
+  }
+}
+function validatePromotionRule(errors, path, rule) {
+  if (!isRecord(rule) || typeof rule.attribute !== "string" || typeof rule.operator !== "string") {
+    push(errors, path, "invalid-value", "a rule is {attribute, operator, values: [...]}");
+    return;
+  }
+  if (!hasRuleAttribute(rule.attribute)) {
+    push(
+      errors,
+      `${path}.attribute`,
+      "unknown-rule-attribute",
+      `"${rule.attribute}" is not in the rule attribute vocabulary`,
+      listRuleAttributeKeys()
+    );
+    return;
+  }
+  if (!RULE_OPERATORS.includes(rule.operator)) {
+    push(errors, `${path}.operator`, "unknown-rule-operator", `"${rule.operator}" is not a rule operator`, RULE_OPERATORS);
+    return;
+  }
+  const attribute = resolveRuleAttribute(rule.attribute);
+  if (!attribute.operators.includes(rule.operator)) {
+    push(
+      errors,
+      `${path}.operator`,
+      "unsupported-rule-operator",
+      `attribute "${rule.attribute}" does not support operator "${rule.operator}"`,
+      attribute.operators
+    );
+  }
+  if (!Array.isArray(rule.values) || rule.values.length === 0) {
+    push(errors, `${path}.values`, "invalid-value", "rule values are a non-empty array of scalars");
+    return;
+  }
+  rule.values.forEach((value, index) => {
+    const t = typeof value;
+    if (t !== "string" && t !== "number" && t !== "boolean") {
+      push(errors, `${path}.values[${index}]`, "invalid-value", `a rule value is a JSON scalar, got ${t}`);
+    }
+  });
+}
+function validateRuleList(errors, path, value) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    push(errors, path, "invalid-value", `expected an array of rules, got ${typeof value}`);
+    return;
+  }
+  value.forEach((rule, index) => validatePromotionRule(errors, `${path}[${index}]`, rule));
+}
+function validatePromotionsSection(errors, section) {
+  const promotions = section.promotions;
+  if (promotions === void 0 || !Array.isArray(promotions)) return;
+  promotions.forEach((promotion, index) => {
+    const path = `promotions.promotions[${index}]`;
+    if (!isRecord(promotion) || typeof promotion.id !== "string" || !promotion.id) {
+      push(errors, path, "invalid-value", "a promotion is {id, code?, isAutomatic?, rules?, applicationMethod}");
+      return;
+    }
+    if (promotion.type !== void 0 && !PROMOTION_TYPES.includes(promotion.type)) {
+      push(errors, `${path}.type`, "invalid-value", `"${String(promotion.type)}" is not a promotion type`, PROMOTION_TYPES);
+    }
+    if (promotion.status !== void 0 && !PROMOTION_STATUSES.includes(promotion.status)) {
+      push(errors, `${path}.status`, "invalid-value", `"${String(promotion.status)}" is not a promotion status`, PROMOTION_STATUSES);
+    }
+    if (promotion.code === void 0 && promotion.isAutomatic !== true) {
+      push(
+        errors,
+        `${path}.code`,
+        "invalid-value",
+        "a promotion needs a code or isAutomatic: true \u2014 otherwise nothing can ever trigger it"
+      );
+    }
+    validateRuleList(errors, `${path}.rules`, promotion.rules);
+    const method = promotion.applicationMethod;
+    if (!isRecord(method)) {
+      push(errors, `${path}.applicationMethod`, "invalid-value", "a promotion carries an applicationMethod ({type, value, targetType, \u2026})");
+      return;
+    }
+    const methodPath = `${path}.applicationMethod`;
+    if (typeof method.type !== "string" || !APPLICATION_METHOD_TYPES.includes(method.type)) {
+      push(errors, `${methodPath}.type`, "invalid-value", `"${String(method.type)}" is not an application method type`, APPLICATION_METHOD_TYPES);
+    }
+    if (typeof method.value !== "number" || method.value < 0) {
+      push(errors, `${methodPath}.value`, "invalid-value", "applicationMethod.value is a non-negative number");
+    }
+    if (typeof method.targetType !== "string" || !APPLICATION_METHOD_TARGET_TYPES.includes(method.targetType)) {
+      push(errors, `${methodPath}.targetType`, "invalid-value", `"${String(method.targetType)}" is not a target type`, APPLICATION_METHOD_TARGET_TYPES);
+    }
+    if (method.allocation !== void 0 && !APPLICATION_METHOD_ALLOCATIONS.includes(method.allocation)) {
+      push(errors, `${methodPath}.allocation`, "invalid-value", `"${String(method.allocation)}" is not an allocation`, APPLICATION_METHOD_ALLOCATIONS);
+    }
+    for (const field of ["maxQuantity", "applyToQuantity", "buyRulesMinQuantity"]) {
+      const value = method[field];
+      if (value !== void 0 && value !== null && (typeof value !== "number" || value < 1)) {
+        push(errors, `${methodPath}.${field}`, "invalid-value", `${field} is a positive integer when set`);
+      }
+    }
+    validateRuleList(errors, `${methodPath}.targetRules`, method.targetRules);
+    validateRuleList(errors, `${methodPath}.buyRules`, method.buyRules);
+  });
+}
+function validateHandleRef(errors, path, name) {
+  if (typeof name !== "string" || !name) {
+    push(errors, path, "invalid-value", "a code reference is a registered handle name (string)");
+    return;
+  }
+  if (!hasHandle(name)) {
+    push(errors, path, "unknown-handle", `handle "${name}" is not registered`, listHandles());
+  }
+}
+function validateCode(errors, section) {
+  for (const field of ["logo", "provider", "auth", "footerCredit"]) {
+    if (section[field] !== void 0) validateHandleRef(errors, `code.${field}`, section[field]);
+  }
+  const components = section.components;
+  if (isRecord(components)) {
+    for (const [slot, handle] of Object.entries(components)) {
+      const slotPath = `code.components.${slot}`;
+      if (!STOREFRONT_COMPONENT_KEYS.includes(slot)) {
+        push(
+          errors,
+          slotPath,
+          "unknown-component-slot",
+          `"${slot}" is not an overridable storefront component`,
+          STOREFRONT_COMPONENT_KEYS
+        );
+        continue;
+      }
+      validateHandleRef(errors, slotPath, handle);
+    }
+  }
+  const routes = section.routes;
+  if (Array.isArray(routes)) {
+    routes.forEach((route, index) => {
+      const routePath = `code.routes[${index}]`;
+      if (!isRecord(route)) {
+        push(errors, routePath, "invalid-value", "a route is {id, path, kind?, chrome?, component}");
+        return;
+      }
+      for (const required of ["id", "path"]) {
+        if (typeof route[required] !== "string" || !route[required]) {
+          push(errors, `${routePath}.${required}`, "missing-field", `route requires a string "${required}"`);
+        }
+      }
+      for (const key of Object.keys(route)) {
+        if (!CODE_ROUTE_KEYS.includes(key)) {
+          push(errors, `${routePath}.${key}`, "unknown-field", `a route has no field "${key}"`, CODE_ROUTE_KEYS);
+        }
+      }
+      if (route.kind !== void 0 && !STORE_ROUTE_KINDS.includes(route.kind)) {
+        push(
+          errors,
+          `${routePath}.kind`,
+          "invalid-value",
+          `"${String(route.kind)}" is not a route kind`,
+          STORE_ROUTE_KINDS
+        );
+      }
+      if (route.chrome !== void 0 && !STORE_ROUTE_CHROMES.includes(route.chrome)) {
+        push(
+          errors,
+          `${routePath}.chrome`,
+          "invalid-value",
+          `"${String(route.chrome)}" is not a route chrome`,
+          STORE_ROUTE_CHROMES
+        );
+      }
+      validateHandleRef(errors, `${routePath}.component`, route.component);
+    });
+  }
+}
+function validateStore(doc) {
+  registerStorefrontBlocks();
+  const errors = [];
+  knownEntities = new Set(listEntityDeclarations());
+  if (isRecord(doc)) {
+    const entitiesSection = doc.entities;
+    if (isRecord(entitiesSection) && isRecord(entitiesSection.definitions)) {
+      for (const key of Object.keys(entitiesSection.definitions)) knownEntities.add(key);
+    }
+  }
+  if (!isRecord(doc)) {
+    push(errors, "", "invalid-document", `a store document is an object, got ${doc === null ? "null" : typeof doc}`);
+    return { ok: false, errors };
+  }
+  if (doc.$kind !== STORE_DOCUMENT_KIND) {
+    push(
+      errors,
+      "$kind",
+      "invalid-document",
+      `expected $kind "${STORE_DOCUMENT_KIND}", got ${JSON.stringify(doc.$kind)}`,
+      [STORE_DOCUMENT_KIND]
+    );
+  }
+  if (doc.store === void 0) {
+    push(errors, "store", "missing-section", 'the "store" section (name/currency/locale) is required', [
+      ...STORE_SECTION_NAMES
+    ]);
+  }
+  for (const [name, section] of Object.entries(doc)) {
+    if (name === "$kind") continue;
+    if (!STORE_SECTION_NAMES.includes(name)) {
+      push(errors, name, "unknown-section", `"${name}" is not a document section`, STORE_SECTION_NAMES);
+      continue;
+    }
+    if (!isRecord(section)) {
+      push(errors, name, "invalid-value", `section "${name}" must be an object with a version`);
+      continue;
+    }
+    const sectionName = name;
+    if (!validateSectionEnvelope(errors, sectionName, section)) continue;
+    if (sectionName === "theme") validateTheme(errors, section);
+    if (sectionName === "entities") validateEntitiesSection(errors, section);
+    if (sectionName === "promotions") validatePromotionsSection(errors, section);
+    if (sectionName === "commerce") validateCommerce(errors, section);
+    if (sectionName === "presentation") validatePresentation(errors, section);
+    if (sectionName === "code") validateCode(errors, section);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function slugifyStoreName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "app";
+}
+function codeRef(value, configPath, handleSuffix, ctx) {
+  const existing = handleNameFor(value);
+  if (existing) return existing;
+  const name = `${ctx.appId}.${handleSuffix}`;
+  if (!ctx.autoRegister) {
+    throw new Error(
+      `exportStore: config.${configPath} holds code that is not a registered handle. Call registerHandle('${name}', value) before exporting, or export with { registerMissingHandles: true } (defineStorefront does).`
+    );
+  }
+  registerHandle(
+    name,
+    value,
+    { description: `Auto-registered from config.${configPath}`, source: "app" },
+    // The app re-declaring its config (module re-evaluation, HMR) re-derives
+    // the same name for a fresh value; replacing is the correct semantics.
+    { replace: true }
+  );
+  return name;
+}
+function findNonJsonPath(value, path) {
+  if (value === null || value === void 0) return null;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean") return null;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const found = findNonJsonPath(value[i], `${path}[${i}]`);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (t === "object") {
+    const record = value;
+    if ("$$typeof" in record) return path;
+    const proto = Object.getPrototypeOf(record);
+    if (proto !== Object.prototype && proto !== null) return path;
+    for (const [key, child] of Object.entries(record)) {
+      const found = findNonJsonPath(child, `${path}.${key}`);
+      if (found) return found;
+    }
+    return null;
+  }
+  return path;
+}
+function hasContent(section) {
+  return Object.keys(section).some((key) => key !== "version");
+}
+function exportStore(config, options = {}) {
+  const ctx = {
+    appId: options.appId ?? slugifyStoreName(config.name),
+    autoRegister: options.registerMissingHandles ?? false
+  };
+  const code = { version: 1 };
+  let presentationLogo;
+  if (config.logo !== void 0) {
+    if (typeof config.logo === "string") presentationLogo = config.logo;
+    else code.logo = codeRef(config.logo, "logo", "logo", ctx);
+  }
+  let footerData;
+  if (config.footer !== void 0) {
+    const { credit, ...rest } = config.footer;
+    if (credit === void 0 || typeof credit === "string") {
+      footerData = config.footer;
+    } else {
+      footerData = rest;
+      code.footerCredit = codeRef(credit, "footer.credit", "footer-credit", ctx);
+    }
+  }
+  let searchData;
+  if (config.search !== void 0) {
+    const { renderSuggestion, ...rest } = config.search;
+    searchData = rest;
+    if (renderSuggestion !== void 0) {
+      code.searchRenderSuggestion = codeRef(
+        renderSuggestion,
+        "search.renderSuggestion",
+        "search-render-suggestion",
+        ctx
+      );
+    }
+  }
+  let authData;
+  if (config.auth !== void 0) {
+    if (isJsonValue(config.auth)) authData = config.auth;
+    else code.auth = codeRef(config.auth, "auth", "auth", ctx);
+  }
+  if (config.provider !== void 0) {
+    code.provider = codeRef(config.provider, "provider", "provider", ctx);
+  }
+  if (config.components !== void 0) {
+    const componentRefs = {};
+    for (const [key, override] of Object.entries(config.components)) {
+      if (override === void 0) continue;
+      componentRefs[key] = codeRef(override, `components.${key}`, `components.${key}`, ctx);
+    }
+    if (Object.keys(componentRefs).length > 0) code.components = componentRefs;
+  }
+  if (config.routes !== void 0 && config.routes.length > 0) {
+    code.routes = config.routes.map(
+      (route) => compact({
+        id: route.id,
+        path: route.path,
+        kind: route.kind,
+        chrome: route.chrome,
+        component: codeRef(route.component, `routes[${route.id}].component`, `routes.${route.id}`, ctx)
+      })
+    );
+  }
+  const sections = {
+    store: compact({
+      version: 1,
+      name: config.name,
+      currency: config.currency,
+      locale: config.locale
+    }),
+    theme: config.theme ? { version: 1, ...compact(config.theme) } : { version: 1 },
+    commerce: compact({
+      version: 1,
+      commerceMode: config.commerceMode,
+      shipping: config.shipping,
+      payments: config.payments,
+      discounts: config.discounts,
+      enquiry: config.enquiry,
+      features: config.features
+    }),
+    presentation: compact({
+      version: 1,
+      announcement: config.announcement,
+      logo: presentationLogo,
+      home: config.home,
+      pages: config.pages,
+      slots: config.slots,
+      nav: config.nav,
+      footer: footerData,
+      imageLoading: config.imageLoading,
+      catalogFacets: config.catalogFacets,
+      productSpecs: config.productSpecs,
+      search: searchData
+    }),
+    content: compact({ version: 1, legal: config.legal, reviews: config.reviews }),
+    catalog: config.catalog ? { version: 1, ...compact(config.catalog) } : { version: 1 },
+    entities: config.entities ? { version: 1, definitions: config.entities } : { version: 1 },
+    promotions: config.promotions ? { version: 1, promotions: config.promotions } : { version: 1 },
+    backend: compact({
+      version: 1,
+      provider: config.backend?.provider,
+      url: config.backend?.url,
+      supabaseUrl: config.supabaseUrl,
+      supabaseAnonKey: config.supabaseAnonKey
+    }),
+    auth: authData ? { version: 1, ...compact(authData) } : { version: 1 },
+    code: compact(code)
+  };
+  const include = {
+    theme: config.theme !== void 0,
+    catalog: config.catalog !== void 0,
+    entities: config.entities !== void 0,
+    promotions: config.promotions !== void 0,
+    auth: authData !== void 0,
+    commerce: hasContent(sections.commerce),
+    presentation: hasContent(sections.presentation),
+    content: hasContent(sections.content),
+    backend: hasContent(sections.backend),
+    code: hasContent(sections.code)
+  };
+  const doc = { $kind: STORE_DOCUMENT_KIND, store: sections.store };
+  for (const name of ["theme", "commerce", "presentation", "content", "catalog", "entities", "promotions", "backend", "auth", "code"]) {
+    if (include[name]) doc[name] = sections[name];
+  }
+  for (const [name, section] of Object.entries(doc)) {
+    if (name === "$kind") continue;
+    const offending = findNonJsonPath(section, name);
+    if (offending) {
+      throw new Error(
+        `exportStore: ${offending} holds a non-serializable value. Code belongs in a registered handle (registerHandle) referenced from the document's code section \u2014 data sections must be pure JSON.`
+      );
+    }
+  }
+  return doc;
+}
+function formatErrors(errors) {
+  return errors.map((e) => ` - ${e.path || "(document)"}: ${e.message}${e.valid ? ` (valid: ${e.valid.join(", ")})` : ""}`).join("\n");
+}
+function hydrateStoreDocument(input, options = {}) {
+  const onError = options.onError ?? "throw";
+  const report = validateStore(input);
+  if (!report.ok) {
+    const message = `Store document failed validation:
+${formatErrors(report.errors)}`;
+    if (onError === "throw") throw new Error(message);
+    console.error(`[storefront] ${message}`);
+  }
+  const doc = input;
+  const resolve = (name, path) => {
+    try {
+      return resolveHandle(name);
+    } catch (err) {
+      if (onError === "throw") throw err;
+      console.error(`[storefront] dropping ${path}: ${errorMessage(err)}`);
+      return void 0;
+    }
+  };
+  const config = { name: doc.store?.name ?? "" };
+  const set = (key, value) => {
+    if (value !== void 0) config[key] = value;
+  };
+  set("currency", doc.store?.currency);
+  set("locale", doc.store?.locale);
+  if (doc.theme) {
+    const { version: _v, ...theme } = doc.theme;
+    set("theme", theme);
+  }
+  if (doc.commerce) {
+    set("commerceMode", doc.commerce.commerceMode);
+    set("shipping", doc.commerce.shipping);
+    set("payments", doc.commerce.payments);
+    set("discounts", doc.commerce.discounts);
+    set("enquiry", doc.commerce.enquiry);
+    set("features", doc.commerce.features);
+  }
+  if (doc.presentation) {
+    set("announcement", doc.presentation.announcement);
+    set("home", doc.presentation.home);
+    set("pages", doc.presentation.pages);
+    set("slots", doc.presentation.slots);
+    set("nav", doc.presentation.nav);
+    set("imageLoading", doc.presentation.imageLoading);
+    set("catalogFacets", doc.presentation.catalogFacets);
+    set("productSpecs", doc.presentation.productSpecs);
+    set("search", doc.presentation.search);
+    if (doc.presentation.logo !== void 0) set("logo", doc.presentation.logo);
+  }
+  if (doc.content) {
+    set("legal", doc.content.legal);
+    set("reviews", doc.content.reviews);
+  }
+  if (doc.catalog) {
+    const { version: _v, ...seed } = doc.catalog;
+    set("catalog", seed);
+  }
+  if (doc.entities?.definitions) set("entities", doc.entities.definitions);
+  if (doc.promotions?.promotions) set("promotions", doc.promotions.promotions);
+  if (doc.backend) {
+    const { provider, url, supabaseUrl, supabaseAnonKey } = doc.backend;
+    if (provider !== void 0 || url !== void 0) set("backend", compact({ provider, url }));
+    set("supabaseUrl", supabaseUrl);
+    set("supabaseAnonKey", supabaseAnonKey);
+  }
+  if (doc.auth) {
+    const { version: _v, ...auth } = doc.auth;
+    set("auth", auth);
+  }
+  const code = doc.code;
+  if (code) {
+    if (code.logo) set("logo", resolve(code.logo, "code.logo"));
+    if (code.provider) set("provider", resolve(code.provider, "code.provider"));
+    if (code.auth) set("auth", resolve(code.auth, "code.auth"));
+    if (code.components) {
+      const components = {};
+      for (const [key, handle] of Object.entries(code.components)) {
+        const value = resolve(handle, `code.components.${key}`);
+        if (value !== void 0) components[key] = value;
+      }
+      if (Object.keys(components).length > 0) set("components", components);
+    }
+    if (code.routes) {
+      const routes = [];
+      for (const route of code.routes) {
+        const component = resolve(
+          route.component,
+          `code.routes[${route.id}].component`
+        );
+        if (component === void 0) continue;
+        routes.push(
+          compact({
+            id: route.id,
+            path: route.path,
+            kind: route.kind,
+            chrome: route.chrome,
+            component
+          })
+        );
+      }
+      if (routes.length > 0) set("routes", routes);
+    }
+    if (code.searchRenderSuggestion) {
+      const renderSuggestion = resolve(
+        code.searchRenderSuggestion,
+        "code.searchRenderSuggestion"
+      );
+      if (renderSuggestion !== void 0) {
+        set("search", { ...doc.presentation?.search ?? {}, renderSuggestion });
+      }
+    }
+    if (code.footerCredit) {
+      const credit = resolve(code.footerCredit, "code.footerCredit");
+      if (credit !== void 0) {
+        set("footer", { ...doc.presentation?.footer ?? {}, credit });
+      }
+    }
+  }
+  if (config.footer === void 0 && doc.presentation?.footer !== void 0) {
+    set("footer", doc.presentation.footer);
+  }
+  return config;
+}
+
+export { STOREFRONT_COMPONENT_KEYS, STOREFRONT_PAGE_KINDS, STORE_BACKEND_PROVIDERS, STORE_COMMERCE_MODES, STORE_DOCUMENT_KIND, STORE_PAYMENT_METHOD_KINDS, STORE_PAYMENT_MODES, STORE_ROUTE_CHROMES, STORE_ROUTE_KINDS, STORE_SECTIONS, STORE_SECTION_NAMES, exportStore, hydrateStoreDocument, isJsonValue, isRecord, sectionToJsonSchema, slugifyStoreName, validateStore };
+//# sourceMappingURL=chunk-GI5BTJK6.js.map
+//# sourceMappingURL=chunk-GI5BTJK6.js.map