@salesforce/storefront-next-runtime 0.4.2 → 1.0.0-alpha.1

package/dist/design-data.d.ts

@@ -1,5 +1,133 @@
 import { r as ShopperExperience } from "./types2.js";
 
+//#region src/design/data/page/attribute-resolution.d.ts
+
+/**
+ * Per-request resolution surface. Storefront-next builds one of these from
+ * the request URL + site config; Page Designer preview builds one against
+ * the BM origin. Both surfaces inject URL-building utilities so this module
+ * stays platform-neutral.
+ */
+interface AttributeResolutionContext {
+  /**
+   * Storefront origin used to absolutize URLs, e.g.
+   * `"https://www.shop.example"`. Page Designer preview supplies the BM
+   * origin instead.
+   */
+  host: string;
+  /**
+   * Builds a static-content URL for a media-file path inside a library.
+   * Mirrors ECOM's `MediaFile.getAbsURL()` chain, parameterized by the
+   * storefront request rather than a JVM `Request`.
+   *
+   * The {@code locale} hint is optional — when omitted, the resolver
+   * substitutes `"default"` so URLs still resolve.
+   */
+  resolveMediaUrl: (ref: {
+    libraryDomain: string;
+    path: string;
+    locale?: string;
+  }) => string;
+  /**
+   * Resolves a library-relative path inside markup (`?$staticlink$`).
+   * When omitted, falls back to {@link resolveMediaUrl}.
+   */
+  staticLinkFor?: (ref: {
+    libraryDomain: string;
+    path: string;
+    locale?: string;
+  }) => string;
+  /**
+   * Default library media domain used when rewriting `?$staticlink$`
+   * references inside markup attributes. Sourced from
+   * {@code manifest.pageLibraryDomain} and threaded through by the
+   * caller. Optional — when omitted, `?$staticlink$` placeholders inside
+   * markup are left untouched and a one-time warning fires.
+   */
+  pageLibraryDomain?: string;
+  /**
+   * Locale hint forwarded to {@link resolveMediaUrl}. Page Designer
+   * preview may omit this when the editor session has no locale; the
+   * resolver substitutes `"default"` in that case.
+   */
+  locale?: string;
+  /**
+   * Optional handler invoked when the resolver encounters a recoverable
+   * problem — malformed envelopes, unknown attribute types, depth limits
+   * exceeded. Lets the consumer route these into its own logger / metric
+   * pipeline instead of the SDK calling `console.warn` directly.
+   *
+   * The runtime dedupes calls to {@code onWarn} per
+   * `(typeId, attrId, attrType)` triple so a misshapen value processed
+   * many times only fires the handler once per process.
+   *
+   * When omitted the runtime stays silent — fits unit tests and Page
+   * Designer preview where stderr noise is undesirable. Production
+   * callers should supply a handler that forwards to their structured
+   * logger.
+   */
+  onWarn?: (warning: AttributeResolutionWarning) => void;
+}
+/**
+ * Payload passed to {@link AttributeResolutionContext.onWarn}. Keep this
+ * shape stable — consumers may pattern-match on `kind` to decide log
+ * level, attach extra metadata, etc.
+ */
+interface AttributeResolutionWarning {
+  /**
+   * Identifier for the kind of issue, useful for routing or grouping in
+   * downstream logging:
+   *
+   * - `malformed-image` / `malformed-file` / `malformed-cms-record` —
+   *   the manifest envelope didn't match the expected shape and the
+   *   value is being passed through unchanged.
+   * - `unknown-attribute-type` — the runtime saw an attribute type it
+   *   doesn't recognize (forward-compat from a newer ECOM).
+   * - `cms-record-depth-exceeded` — recursive cms_record nesting hit
+   *   the resolver's safety limit.
+   * - `staticlink-rewrite-skipped` — markup contains `?$staticlink$`
+   *   placeholders but `ctx.pageLibraryDomain` was not configured, so
+   *   the placeholder is left in the source. Fires once per process
+   *   regardless of how many markup attributes hit it (tracked via the
+   *   {@code typeId}/{@code attrId} fields, both empty strings, in the
+   *   {@code warnOnce} dedup key).
+   */
+  kind: 'malformed-image' | 'malformed-file' | 'malformed-cms-record' | 'cms-record-depth-exceeded' | 'unknown-attribute-type' | 'staticlink-rewrite-skipped';
+  /** Human-readable message — safe to log directly. */
+  message: string;
+  /** Component type id the offending attribute belongs to. */
+  typeId: string;
+  /** Attribute id within the component. */
+  attrId: string;
+  /** The attribute's declared type, when known. Empty for inner cms_record entries that don't carry a type. */
+  attrType: string;
+}
+/**
+ * Slim attribute definition used by the resolver to dispatch by type.
+ * Mirrors the fields {@code AttributeDefinition} ships in SCAPI's
+ * `componentTypes` map. Defined here so the resolver doesn't take a
+ * dependency on the larger SCAPI generated types.
+ */
+interface AttributeDefinition {
+  /** Attribute identifier as authored by the merchant (e.g. `"hero"`). */
+  id: string;
+  /**
+   * Lower-case attribute type identifier matching ECOM's
+   * {@code AttributeDefinition.Type#getID}. Examples:
+   * `"string"`, `"text"`, `"image"`, `"markup"`, `"file"`, `"cms_record"`.
+   */
+  type: string;
+  /**
+   * Default value declared on the attribute definition. Used by component
+   * data composition as a fallback when neither the active locale nor the
+   * fallback locale has a value for this attribute (see
+   * {@code processPage}'s `visitComponent`). The shape is whatever the
+   * attribute's `type` would normally hold — a string for `string`/`text`,
+   * an envelope for `image`/`file`, etc.
+   */
+  defaultValue?: unknown;
+}
+//#endregion
 //#region src/design/data/types.d.ts
 
 /**
@@ -19,6 +147,22 @@ interface PageManifest {
   variations: Record<string, VariationEntry>;
   /** The variation ID to use when no other variation's rule matches. */
   defaultVariation: string;
+  /**
+   * Per-component-type attribute definitions hoisted from the page layout
+   * by the manifest builder, deduped by `typeId`. Used by the MRT
+   * attribute resolver to dispatch by attribute type without round-tripping
+   * to ECOM. Optional — older manifests may not include this field.
+   */
+  componentTypes?: Record<string, {
+    attributeDefinitions: Record<string, AttributeDefinition>;
+  }>;
+  /**
+   * Media-file domain name of the page's owning library. Used by the markup
+   * URL rewriter to resolve `?$staticlink$` placeholders at request time.
+   * Set by the manifest builder from `library.getMediaFileDomain().getDomainName()`.
+   * Optional — older manifests may not include this field.
+   */
+  pageLibraryDomain?: string;
   /**
    * Component visibility rule definitions extracted from the page layout.
    * Maps each component ID to its array of rule objects and a flag indicating
@@ -27,7 +171,7 @@ interface PageManifest {
   componentInfo: {
     [componentId: string]: {
       /** The visibility rules for this component. */
-      visibilityRules: VisibilityRuleDef[];
+      visibilityRules?: VisibilityRuleDef[];
       /**
        * Locale-specific content attributes for this component. Keyed by locale
        * (e.g. `"en_US"`), each entry contains attribute values that are merged
@@ -36,10 +180,16 @@ interface PageManifest {
       content?: {
         [locale: string]: Record<string, unknown>;
       };
-      /** Data binding metadata for this component, or `null` if not bound. */
-      dataBinding?: ComponentDataBinding | null;
+      /** Data binding metadata for this component. Omitted when the component has no bindings. */
+      dataBinding?: ComponentDataBinding;
+      /** Whether this component is a fragment (a reusable, externally-managed content asset). */
+      fragment?: boolean;
+      /** Custom component data produced by the type's serialize script. Omitted when the component has no custom data. */
+      custom?: Record<string, unknown>;
+      /** Display name of the component. Omitted when the component has no name. */
+      name?: string;
       /** Region-level configuration (e.g. maxComponents limits), keyed by region ID. */
-      regions: {
+      regions?: {
         [regionId: string]: RegionInfo;
       };
     };
@@ -48,13 +198,13 @@ interface PageManifest {
 /** Region-level configuration extracted from the page manifest, including type filters and component limits. */
 interface RegionInfo {
   /** The name of the region. */
-  name: string;
+  name?: string;
   /** The component type exclusions for the region. */
-  componentTypeExclusions: string[] | null;
+  componentTypeExclusions?: string[];
   /** The component type inclusions for the region. */
-  componentTypeInclusions: string[] | null;
-  /** Maximum number of visible components to render in this region, or `null` for no limit. */
-  maxComponents: number | null;
+  componentTypeInclusions?: string[];
+  /** Maximum number of visible components to render in this region. Omitted when there is no limit. */
+  maxComponents?: number;
 }
 /**
  * Site-wide manifest containing content assignments that map product and category
@@ -152,13 +302,52 @@ interface VariationEntry {
   ruleRequiresContext: boolean;
   /** The visibility rule that must pass for this variation to be selected. Undefined for the default variation. */
   visibilityRule?: VisibilityRuleDef;
-  /** The full page data for this variation. */
+  /**
+   * The full page data for this variation. Includes the SCAPI-shape page
+   * metadata fields (`name`, `aspectTypeId`, `description`, `pageTitle`,
+   * `pageDescription`, `pageKeywords`) populated from the default-locale
+   * `Page` by the manifest builder. Non-default-locale overrides for
+   * these fields live in {@link pageContent}.
+   */
   page: ShopperExperience.schemas['Page'];
+  /**
+   * Per-locale overlay for the variation's page metadata. When the request
+   * locale is not the default and the page metadata differs, the manifest
+   * builder writes the **full set** of locale-specific page metadata fields
+   * here (full replacement, not diff — see Q6 of the design plan).
+   *
+   * Each entry is a partial `Page` carrying only the metadata fields that
+   * may be locale-overridden (`name`, `aspectTypeId`, `description`,
+   * `pageTitle`, `pageDescription`, `pageKeywords`); structural fields
+   * (`id`, `typeId`, `regions`) live on {@link page} and are never
+   * locale-overlaid.
+   *
+   * Absent or missing entries fall back to the default-locale page
+   * metadata. Optional — older manifests may not include this field.
+   */
+  pageContent?: {
+    [locale: string]: PageMetadataOverlay;
+  };
   /** Page-level region configuration for this variation, keyed by region ID. These are top-level regions owned by the page itself, not nested under a component. */
   regions: {
     [regionId: string]: RegionInfo;
   };
 }
+/**
+ * Subset of {@link ShopperExperience.schemas#Page} fields that the manifest
+ * builder may locale-overlay. Stored on
+ * {@link VariationEntry.pageContent} keyed by locale ID. Structural fields
+ * (`id`, `typeId`, `regions`) are intentionally excluded — they are not
+ * locale-scoped.
+ */
+interface PageMetadataOverlay {
+  name?: string;
+  aspectTypeId?: string;
+  description?: string;
+  pageTitle?: string;
+  pageDescription?: string;
+  pageKeywords?: string;
+}
 /**
  * A visibility rule definition that controls when a page variation or component
  * is shown. All conditions within a rule use AND logic — every specified
@@ -185,12 +374,6 @@ interface VisibilityRuleDef {
  * is typically resolved lazily — only fetched when a rule actually needs it.
  */
 type QualifierContext = ShopperExperience.schemas['QualifierResolveResponse'];
-/**
- * A resolved data binding object containing the fields returned by the data
- * provider for a specific record. For example, a resolved `content_asset`
- * might contain `{ title: "Winter Sale", body: "<div>…</div>" }`.
- */
-type ResolvedDataBinding = ShopperExperience.schemas['ResolvedDataBinding'];
 /**
  * The type of identifier used to look up a page. Determines how the ID is
  * resolved to a page manifest:
@@ -231,6 +414,24 @@ interface PageProcessorContext {
   };
   /** The locale to use when resolving locale-specific component content (e.g. `"en_US"`). */
   locale: string;
+  /** The site's default locale, used as a fallback when the current locale has no content entry (e.g. `"en_US"`). */
+  defaultLocale: string;
+  /**
+   * Per-request resolution surface used by {@link resolveAttributeValues} to
+   * convert manifest envelopes into the wire shape SCAPI `getPage` would have
+   * returned. The storefront-next middleware builds it once per request and
+   * Page Designer preview supplies an editor-mode equivalent.
+   */
+  attrCtx: AttributeResolutionContext;
+  /**
+   * Per-component-type attribute definitions hoisted by the manifest builder.
+   * Keyed by `typeId`. Optional — when omitted, the resolver falls back to
+   * structural detection for the image envelope and passes everything else
+   * through.
+   */
+  componentTypes?: Record<string, {
+    attributeDefinitions: Record<string, AttributeDefinition>;
+  }>;
   /**
    * When `true` (default), invisible components are removed from the tree and
    * regions are truncated to their `maxComponents` limit. When `false`, invisible
@@ -239,57 +440,6 @@ interface PageProcessorContext {
    */
   pruneInvisible?: boolean;
 }
-/**
- * Filters a page's components based on their visibility rules and resolves
- * data binding expressions in a single traversal. Traverses the page tree
- * using the visitor pattern and:
- *
- * 1. Removes any component whose visibility rules do not pass against the
- *    shopper's qualifier context.
- * 2. Resolves data binding expressions in each surviving component's `data`
- *    attributes using the resolved data bindings from context resolution.
- *
- * A component is visible if **any** of its visibility rules pass (OR logic).
- * If a component has rules and none of them pass, it is removed. Components
- * without rules are always included.
- *
- * @param page - The page to process.
- * @param context - The processing context with qualifier data, visibility rules, and resolved data bindings.
- * @returns A new page with invisible components filtered out and data binding expressions resolved.
- *
- * @example
- * ```ts
- * import { processPage } from '@salesforce/storefront-next-runtime/design/data';
- *
- * const page = {
- *     id: 'homepage',
- *     typeId: 'storePage',
- *     regions: [{
- *         id: 'main',
- *         components: [
- *             { id: 'public-banner', typeId: 'commerce_assets.heroBanner', regions: [] },
- *             { id: 'loyalty-offer', typeId: 'commerce_assets.promoTile', regions: [] },
- *         ],
- *     }],
- * };
- *
- * // The "loyalty-offer" component requires the shopper to be in "loyalty-members"
- * const componentInfo = {
- *     'public-banner': { visibilityRules: [] },
- *     'loyalty-offer': {
- *         visibilityRules: [{ customerGroups: ['loyalty-members'] }],
- *     },
- * };
- *
- * // Guest shopper — not in any customer group
- * const filtered = processPage(page, {
- *     qualifiers: { customerGroups: {}, campaignQualifiers: {} },
- *     componentInfo,
- * });
- * // filtered.regions[0].components has only "public-banner"
- * // "loyalty-offer" was removed because the shopper isn't a loyalty member
- * ```
- */
 declare function processPage(page: ShopperExperience.schemas['Page'], processorContext: PageProcessorContext): ShopperExperience.schemas['Page'];
 //#endregion
 //#region src/design/data/page/transform.d.ts
@@ -576,88 +726,6 @@ declare class RequiredError extends Error {
   static assert<TValue>(value: TValue, message: string, isEmpty?: (value: TValue) => boolean): asserts value is NonNullable<TValue>;
 }
 //#endregion
-//#region src/design/data/page/resolve-data-bindings.d.ts
-/**
- * Parses a binding expression string into its provider type and field name.
- * Supports the bare `type.field` format.
- *
- * @param expression - The expression string to parse.
- * @returns The parsed type and field, or `null` if the expression is invalid.
- *
- * @example
- * ```ts
- * parseExpression('content_asset.title');  // { type: 'content_asset', field: 'title' }
- * parseExpression('invalid');              // null
- * ```
- */
-declare function parseExpression(expression: string): {
-  type: string;
-  field: string;
-} | null;
-/**
- * Resolves a single binding expression against the component's data contexts
- * and the resolved data bindings from context resolution.
- *
- * Returns the resolved field value, or an empty string if the expression is
- * invalid, the matching context or record is not found, or the field does not
- * exist on the resolved record.
- *
- * @param expression - The expression string (e.g. `"content_asset.body"`).
- * @param contexts - The component's data binding contexts.
- * @param dataBindings - The resolved data bindings from {@link QualifierContext}.
- * @returns The resolved value, or `''` if resolution fails.
- */
-declare function resolveExpression(expression: string, contexts: DataBindingRequirement[], dataBindings: NonNullable<QualifierContext['dataBindings']>): unknown;
-/**
- * Resolves data binding expressions for a single component. Replaces attribute
- * values in the component's `data` with the resolved values from context
- * resolution. Attributes without a matching expression are preserved as-is.
- * When an expression cannot be resolved, the attribute value is set to an
- * empty string.
- *
- * Returns the component unchanged if it has no data binding metadata or if
- * `dataBindings` is `undefined`.
- *
- * @param component - The component to resolve data bindings for.
- * @param binding - The component's data binding metadata from the page manifest's `componentInfo`, or `null`/`undefined` if not bound.
- * @param dataBindings - The resolved data bindings from {@link QualifierContext}, or `undefined` if no bindings were resolved.
- * @returns The component with resolved attribute values, or the original component if no bindings apply.
- *
- * @example
- * ```ts
- * import { resolveComponentDataBindings } from '@salesforce/storefront-next-runtime/design/data';
- *
- * const component = {
- *     id: 'banner',
- *     typeId: 'commerce_assets.contentBanner',
- *     data: { heading: 'Fallback Title', body: 'Fallback Body' },
- *     regions: [],
- * };
- *
- * const binding = {
- *     expressions: {
- *         heading: 'content_asset.title',
- *         body: 'content_asset.body',
- *     },
- *     contexts: [{ type: 'content_asset', id: 'winter-sale-uuid' }],
- * };
- *
- * const dataBindings = {
- *     content_asset: {
- *         'winter-sale-uuid': {
- *             title: 'Winter Sale',
- *             body: '<div>Free Shipping on all orders!</div>',
- *         },
- *     },
- * };
- *
- * const resolved = resolveComponentDataBindings(component, binding, dataBindings);
- * // resolved.data.heading === 'Winter Sale'
- * // resolved.data.body === '<div>Free Shipping on all orders!</div>'
- * ```
- */
-declare function resolveComponentDataBindings(component: ShopperExperience.schemas['Component'], binding: ComponentDataBinding | null | undefined, dataBindings: QualifierContext['dataBindings']): ShopperExperience.schemas['Component'];
-//#endregion
 //#region src/design/data/page/resolve-page.d.ts
 /**
  * Main entry point for the page resolution pipeline. Orchestrates the full flow:
@@ -679,6 +747,7 @@ declare function resolveComponentDataBindings(component: ShopperExperience.schem
  * @param options.manifestStorage - Storage implementation for fetching manifests.
  * @param options.contextResolver - Optional async function that returns the shopper's qualifier context. Only called if a visibility rule needs it.
  * @param options.aspectType - The aspect type to resolve the page for when the identifier type is `'product'` or `'category'`.
+ * @param options.categoryId - Optional fallback category ID (or a Promise resolving to one) used only when `identifierType` is `'product'` and the product has no content assignment for the requested aspect type. The promise is awaited lazily — the happy path never pays for it.
  * @param options.pruneInvisible - When `true` (default), invisible and overflow components are removed. When `false`, they are kept but marked `visible: false` for design/preview mode.
  * @returns The fully resolved and filtered page, or `null`.
  *
@@ -720,226 +789,39 @@ declare function resolvePage({
   id,
   identifierType,
   aspectType,
+  categoryId,
   locale,
+  defaultLocale,
   manifestStorage,
   contextResolver,
+  attrCtx,
   pruneInvisible
 }: {
   id: string;
   identifierType: IdentifierType;
   aspectType?: string;
+  /**
+   * Fallback category ID (or a Promise resolving to one) consulted only
+   * when `identifierType === 'product'` and the product has no content
+   * assignment for the requested aspect type. Awaited lazily — the happy
+   * path skips it.
+   */
+  categoryId?: string | Promise<string | null | undefined> | null;
   locale: string;
+  defaultLocale: string;
   manifestStorage: ManifestStorage;
   contextResolver?: ContextResolver;
+  /**
+   * Per-request resolution surface for attribute envelope rewriting. Built
+   * once per request by the storefront-next middleware (or Page Designer
+   * preview). The `componentTypes` map travels on the
+   * {@link PageManifest} itself and is read off the manifest below before
+   * being threaded into {@link processPage}.
+   */
+  attrCtx: AttributeResolutionContext;
   pruneInvisible?: boolean;
 }): Promise<ShopperExperience.schemas['Page'] | null>;
 //#endregion
-//#region src/design/data/manifest/resolve-dynamic-page-id.d.ts
-/**
- * Converts a product or category identifier into a page ID by looking up
- * content assignments in the site manifest. For categories, the lookup
- * traverses the category hierarchy from the given category up to the root,
- * returning the first matching assignment.
- *
- * Returns `null` if no content assignment is found for the identifier or if
- * the identifier type has no registered resolver.
- *
- * @param options - The resolution options.
- * @param options.id - The identifier to resolve (product ID, category ID, or page ID).
- * @param options.identifierType - The type of identifier: `'product'`, `'category'`, or `'page'`.
- * @param options.siteManifest - The site manifest containing content assignments and category hierarchy.
- * @returns The resolved page ID, or `null` if no assignment was found.
- *
- * @example
- * ```ts
- * import { resolveDynamicPageId } from '@salesforce/storefront-next-runtime/design/data';
- *
- * const siteManifest = {
- *     contentObjectAssignments: {
- *         plp: {
- *             category: {
- *                 'mens-shoes': {
- *                     lookupMode: 'category-explicit',
- *                     contentId: 'page-mens-shoes-plp',
- *                 },
- *             },
- *         },
- *     },
- *     categories: {
- *         'mens-running-shoes': { name: 'Running Shoes', parentCategory: 'mens-shoes' },
- *         'mens-shoes': { name: "Men's Shoes" },
- *     },
- * };
- *
- * // Direct match
- * resolveDynamicPageId({ id: 'mens-shoes', identifierType: 'category', siteManifest });
- * // => 'page-mens-shoes-plp'
- *
- * // Inherited from parent category
- * resolveDynamicPageId({ id: 'mens-running-shoes', identifierType: 'category', siteManifest });
- * // => 'page-mens-shoes-plp' (found via parent traversal)
- *
- * // No assignment found
- * resolveDynamicPageId({ id: 'womens-shoes', identifierType: 'category', siteManifest });
- * // => null
- * ```
- */
-declare function resolveDynamicPageId<TIdentifier extends IdentifierType = IdentifierType>({
-  id,
-  identifierType,
-  siteManifest,
-  aspectType
-}: {
-  id: string;
-  identifierType: TIdentifier;
-  aspectType: string;
-  siteManifest?: SiteManifest | null;
-}): string | null;
-//#endregion
-//#region src/design/data/manifest/get-page.d.ts
-/**
- * Selects the appropriate page variation from a manifest by evaluating each
- * variation's visibility rule in order. Returns the first variation whose rule
- * passes, or falls back to the manifest's default variation.
- *
- * The qualifier context is resolved lazily — the `contextResolver` is only
- * called when a variation's `ruleRequiresContext` flag is `true`, and only
- * once (the result is cached for subsequent variations).
- *
- * @param manifest - The page manifest containing all variations.
- * @param options - Resolution options.
- * @param options.contextResolver - Optional async function that returns the shopper's qualifier context. Only called if a variation's rule needs it.
- * @param options.locale - The current locale (e.g. `"en_US"`). Used to evaluate locale-based visibility rules.
- * @returns The selected variation entry and resolved context, or `null` if no variation (including default) exists.
- *
- * @example
- * ```ts
- * import { getPageFromManifest } from '@salesforce/storefront-next-runtime/design/data';
- *
- * const manifest = {
- *     pageId: 'homepage',
- *     context: { campaignQualifiers: [], customerGroups: ['vip-customers'], dataBindings: [] },
- *     variationOrder: ['vip-homepage', 'holiday-homepage'],
- *     variations: {
- *         'vip-homepage': {
- *             ruleRequiresContext: true,
- *             pageRequiresContext: false,
- *             visibilityRule: { activeLocales: ['en-US'], customerGroups: ['vip-customers'] },
- *             page: { id: 'homepage', typeId: 'storePage', regions: [] },
- *             regions: {},
- *         },
- *         'holiday-homepage': {
- *             ruleRequiresContext: false,
- *             pageRequiresContext: false,
- *             visibilityRule: {
- *                 activeLocales: ['en-US'],
- *                 schedule: {
- *                     start: new Date('2026-12-01').toISOString(),
- *                     end: new Date('2026-12-31').toISOString(),
- *                 },
- *             },
- *             page: { id: 'homepage', typeId: 'storePage', regions: [] },
- *             regions: {},
- *         },
- *         'default-homepage': {
- *             ruleRequiresContext: false,
- *             pageRequiresContext: false,
- *             page: { id: 'homepage', typeId: 'storePage', regions: [] },
- *             regions: {},
- *         },
- *     },
- *     defaultVariation: 'default-homepage',
- *     componentInfo: {},
- * };
- *
- * // VIP shopper — matches first variation
- * const result = await getPageFromManifest(manifest, {
- *     locale: 'en-US',
- *     contextResolver: async () => ({
- *         customerGroups: { 'vip-customers': true },
- *         campaignQualifiers: {},
- *     }),
- * });
- * // result.entry === manifest.variations['vip-homepage']
- *
- * // Non-VIP shopper outside holiday window — falls back to default
- * const fallback = await getPageFromManifest(manifest, {
- *     locale: 'en-US',
- *     contextResolver: async () => ({
- *         customerGroups: {},
- *         campaignQualifiers: {},
- *     }),
- * });
- * // fallback.entry === manifest.variations['default-homepage']
- * ```
- */
-declare function getPageFromManifest(manifest: PageManifest, {
-  contextResolver,
-  locale
-}: {
-  contextResolver?: ContextResolver;
-  locale: string;
-}): Promise<{
-  entry: VariationEntry;
-  context: QualifierContext | null;
-} | null>;
-//#endregion
-//#region src/design/data/manifest/content-assignment-resolvers.d.ts
-/**
- * The result of resolving an identifier through a content assignment resolver.
- * Contains the object type, aspect type, and ordered list of keys to search
- * in the site manifest's content assignments.
- */
-interface ResolvedContentAssignmentLookup {
-  /** The type of commerce object (e.g. `'product'`, `'category'`). */
-  objectType: string;
-  /** Ordered list of object IDs to search in the site manifest's content assignments. */
-  keys: string[];
-}
-/**
- * A function that converts an identifier key (e.g., a product or category ID)
- * into a {@link ResolvedContentAssignmentLookup} describing where to search
- * in the site manifest for the assigned page ID.
- */
-type ContentAssignmentResolver = (key: string, manifest?: SiteManifest | null) => ResolvedContentAssignmentLookup;
-/**
- * Registry of content assignment resolvers keyed by {@link IdentifierType}.
- * Each resolver knows how to convert its identifier type into a set of lookup
- * keys for the site manifest.
- *
- * Built-in resolvers:
- * - **`'product'`** — Maps a product ID to a single PDP lookup key.
- * - **`'category'`** — Maps a category ID to an ordered list of keys that
- *   traverses the category hierarchy from child to root, enabling inherited
- *   page assignments.
- *
- * The `'page'` identifier type has no resolver — page IDs are used directly.
- *
- * @example
- * ```ts
- * import { ContentAssignmentResolvers } from '@salesforce/storefront-next-runtime/design/data';
- *
- * // Resolve a product identifier for PDP lookup
- * const productResolver = ContentAssignmentResolvers.get('product');
- * productResolver('nike-air-max-90');
- * // => { objectType: 'product', aspectType: 'pdp', keys: ['nike-air-max-90'] }
- *
- * // Resolve a category identifier — traverses hierarchy to find inherited assignments
- * const categoryResolver = ContentAssignmentResolvers.get('category');
- * const siteManifest = {
- *     categories: {
- *         'mens-running-shoes': { name: 'Running Shoes', parentCategory: 'mens-shoes' },
- *         'mens-shoes': { name: "Men's Shoes", parentCategory: 'mens' },
- *         'mens': { name: 'Men' },
- *     },
- *     contentObjectAssignments: {},
- * };
- * categoryResolver('mens-running-shoes', siteManifest);
- * // => { objectType: 'category', aspectType: 'plp', keys: ['mens-running-shoes', 'mens-shoes', 'mens'] }
- * ```
- */
-declare const ContentAssignmentResolvers: Map<string, ContentAssignmentResolver>;
-//#endregion
 //#region src/design/data/validate-rule.d.ts
 /**
  * Evaluates a visibility rule against a shopper's qualifier context.
@@ -986,5 +868,5 @@ declare const ContentAssignmentResolvers: Map<string, ContentAssignmentResolver>
  */
 declare function validateRule(rule: VisibilityRuleDef, locale: string, context?: QualifierContext | null): boolean;
 //#endregion
-export { CampaignQualifier, ComponentDataBinding, ContentAssignmentResolvers, ContextResolver, DataBindingRequirement, IdentifierType, InferNodeFromType, ManifestStorage, PageManifest, PageManifestContext, type PageProcessorContext, type PageVisitor, QualifierContext, RegionInfo, RequiredError, ResolvedDataBinding, SiteManifest, VariationEntry, VisibilityRuleDef, type VisitorContext, VisitorContextType, getPageFromManifest, parseExpression, processPage, resolveComponentDataBindings, resolveDynamicPageId, resolveExpression, resolvePage, transformComponent, transformPage, transformRegion, validateRule };
+export { type AttributeResolutionContext, type AttributeResolutionWarning, type ContextResolver, type IdentifierType, type InferNodeFromType, type ManifestStorage, type PageManifest, type PageProcessorContext, type PageVisitor, type QualifierContext, RequiredError, type SiteManifest, type VisibilityRuleDef, type VisitorContext, type VisitorContextType, processPage, resolvePage, transformComponent, transformPage, transformRegion, validateRule };
 //# sourceMappingURL=design-data.d.ts.map