@wix/agent-skills 1.26.0 → 1.27.0

package/skills/wix-headless-templates/shared/capabilities/site-search/app/wix/site-search/search-store.ts

@@ -0,0 +1,235 @@
+// The results page as a framework-free store — the logic behind useSearch, usable from React
+// (useSearch wraps it with useSyncExternalStore), from a static page or Vue/Svelte (subscribe and
+// render), or as the specification for a port. Same shape as the vertical stores: state, actions,
+// subscribe/getState, emit after every change.
+//
+// Two views of one query: GROUPED (type null — federatedSearch, a few hits per type, no paging) and
+// SINGLE-TYPE (type set — search with documentType, sort, filter, facets, offset paging). The query
+// (q, type, sort, filter, limits) is identified BY VALUE; a change refetches from the first page, a
+// late response from a superseded query is dropped. Paging appends (offset = hits shown so far).
+//
+// SSR-friendly: seed with `initialGroups`/`initialIndexed` or `initialPage` from the SAME q/type and
+// no client fetch happens for the first render. URL state (`?q=&type=`) is the surface's job, not
+// the store's. One store per mounted results surface: createSearchStore(), not a singleton.
+import { searchAll, searchType } from "./search";
+import { GROUP_LIMIT, PAGE_LIMIT, clampQuery, sortsFor } from "./search-core";
+import type { SearchDocType, SearchFilter, SearchGroup, SearchPage, SearchSort } from "./types";
+
+export interface SearchStoreOptions {
+  q?: string;
+  /** null = the grouped view. */
+  type?: SearchDocType | null;
+  sort?: SearchSort;
+  filter?: SearchFilter;
+  /** Hits per type in the grouped view (default 4). */
+  groupLimit?: number;
+  /** Page size of the single-type view (default 12). */
+  pageLimit?: number;
+  /** Server-fetched grouped result — must come from the SAME q with type null. */
+  initialGroups?: SearchGroup[] | null;
+  initialIndexed?: boolean | null;
+  /** Server-fetched first page — must come from the SAME q/type/sort/filter. */
+  initialPage?: SearchPage | null;
+}
+
+/** Everything a results surface renders from. Read it with getState() or through a subscription. */
+export interface SearchState {
+  q: string;
+  type: SearchDocType | null;
+  sort: SearchSort;
+  filter: SearchFilter;
+  /** Grouped view: null while the first load is in flight — render skeletons, not an empty state. [] = no results. */
+  groups: SearchGroup[] | null;
+  /** Grouped view: see SearchAllResult.indexed. */
+  indexed: boolean | null;
+  /** Single-type view: null while the first load is in flight. */
+  page: SearchPage | null;
+  /** The sorts the current type offers (relevance always). */
+  sorts: SearchSort[];
+  loading: boolean;
+  loadingMore: boolean;
+  hasMore: boolean;
+  error: string | null;
+}
+
+export interface SearchStore {
+  getState(): SearchState;
+  subscribe(listener: () => void): () => void;
+  /** Run the first query unless the seed already answered it. Call once when mounted (a browser). */
+  start(): void;
+  /** Stop reacting; drop late responses. */
+  stop(): void;
+  /** A new phrase (trimmed, cut at 100 chars) — refetches from the first page in the current view. */
+  setQuery(q: string): void;
+  /** Switch views: a type for its single-type page, null for the grouped view. Resets sort and filter. */
+  setType(type: SearchDocType | null): void;
+  setSort(sort: SearchSort): void;
+  setFilter(filter: SearchFilter): void;
+  /** Single-type view: append the next page. No-op while loading or when there is none. */
+  loadMore(): Promise<void>;
+  /** Re-run the current query after an error. */
+  retry(): void;
+}
+
+export function createSearchStore(options: SearchStoreOptions = {}): SearchStore {
+  let q = clampQuery(options.q);
+  let type: SearchDocType | null = options.type ?? null;
+  let sort: SearchSort = options.sort ?? "relevance";
+  let filter: SearchFilter = options.filter ?? {};
+  const groupLimit = options.groupLimit ?? GROUP_LIMIT;
+  const pageLimit = options.pageLimit ?? PAGE_LIMIT;
+  let attempt = 0;
+  const key = () => JSON.stringify([q, type, sort, filter, groupLimit, pageLimit, attempt]);
+
+  let groups: SearchGroup[] | null = type === null ? (options.initialGroups ?? null) : null;
+  let indexed: boolean | null = options.initialIndexed ?? null;
+  let page: SearchPage | null = type !== null ? (options.initialPage ?? null) : null;
+  let error: string | null = null;
+  let loadingMore = false;
+  // The query the current data answers (null = nothing answered yet).
+  let pageKey: string | null = groups !== null || page !== null ? key() : null;
+  let inflight = false;
+  let started = false;
+  let generation = 0;
+  const listeners = new Set<() => void>();
+  let snapshot: SearchState | null = null;
+  const emit = () => {
+    snapshot = null;
+    for (const fn of listeners) fn();
+  };
+
+  function getState(): SearchState {
+    if (snapshot) return snapshot;
+    const answered = pageKey === key();
+    snapshot = {
+      q,
+      type,
+      sort,
+      filter,
+      groups: type === null && answered ? groups : null,
+      indexed: type === null && answered ? indexed : null,
+      page: type !== null && answered ? page : null,
+      sorts: type ? sortsFor(type) : ["relevance"],
+      loading: !!q && (!answered || (type === null ? groups === null : page === null)),
+      loadingMore: answered && loadingMore,
+      hasMore: answered && !!page?.hasNext,
+      error: answered ? error : null,
+    };
+    return snapshot;
+  }
+
+  function run(): void {
+    if (!started) return;
+    const k = key();
+    const id = ++generation;
+    pageKey = k;
+    groups = null;
+    page = null;
+    indexed = null;
+    error = null;
+    loadingMore = false;
+    if (!q) {
+      // Nothing to search — an empty, answered state (no request).
+      groups = type === null ? [] : null;
+      inflight = false;
+      emit();
+      return;
+    }
+    inflight = true;
+    emit();
+    const request = type === null ? searchAll(q, { limit: groupLimit }) : searchType({ q, type, sort, filter, limit: pageLimit, offset: 0 });
+    request
+      .then((res) => {
+        if (generation !== id) return; // superseded — drop it
+        if ("groups" in res) {
+          groups = res.groups;
+          indexed = res.indexed;
+        } else {
+          page = res;
+        }
+        inflight = false;
+        emit();
+      })
+      .catch((e) => {
+        if (generation !== id) return;
+        groups = type === null ? [] : null;
+        page = null;
+        inflight = false;
+        error = e instanceof Error ? e.message : String(e);
+        emit();
+      });
+  }
+
+  function changed(): void {
+    if (key() === pageKey) return; // same values — same data
+    if (started) run();
+    else emit();
+  }
+
+  return {
+    getState,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    start() {
+      if (started) return;
+      started = true;
+      // The SSR seed answered this exact query — no fetch; a dropped first load reruns.
+      if (pageKey !== key() || (!inflight && (type === null ? groups === null : page === null))) run();
+    },
+    stop() {
+      started = false;
+      generation++;
+      inflight = false;
+    },
+    setQuery(next) {
+      const value = clampQuery(next);
+      if (value === q) return;
+      q = value;
+      changed();
+    },
+    setType(next) {
+      if (next === type) return;
+      type = next;
+      sort = "relevance";
+      filter = {};
+      changed();
+    },
+    setSort(next) {
+      if (next === sort || (type && !sortsFor(type).includes(next))) return;
+      sort = next;
+      changed();
+    },
+    setFilter(next) {
+      filter = next;
+      changed();
+    },
+    async loadMore() {
+      const current = page;
+      if (!type || !current?.hasNext || loadingMore || pageKey !== key()) return;
+      const id = generation;
+      loadingMore = true;
+      error = null;
+      emit();
+      try {
+        const more = await searchType({ q, type, sort, filter, limit: pageLimit, offset: current.hits.length });
+        if (generation !== id) return;
+        const seen = new Set(current.hits.map((h) => h.id));
+        page = { ...more, offset: 0, hits: [...current.hits, ...more.hits.filter((h) => (seen.has(h.id) ? false : (seen.add(h.id), true)))] };
+      } catch (e) {
+        if (generation !== id) return;
+        error = e instanceof Error ? e.message : String(e);
+      } finally {
+        if (generation === id) {
+          loadingMore = false;
+          emit();
+        }
+      }
+    },
+    retry() {
+      attempt++;
+      run();
+    },
+  };
+}

package/skills/wix-headless-templates/shared/capabilities/site-search/app/wix/site-search/search.ts

@@ -0,0 +1,80 @@
+// Site Search reads (@wix/search `siteSearch`, the federated service) over the SDK — the only file on
+// this transport that sees raw search documents. The rules, bodies and mappers live in ./search-core
+// (shared with the REST twin in rest/search.ts); this file is the transport only. Every call runs as
+// the visitor: both search surfaces answer an anonymous visitor token (observed live; the typings say
+// APP and the docs show an admin client — a closed door here means an Astro API route with
+// auth.elevate(wixSiteSearch.search), per CUSTOM_OPERATIONS.md). Copy as-is; extend by adding
+// functions (`related`, `trending`, `federatedAutocomplete` exist on the same module).
+// docs: https://dev.wix.com/docs/api-reference/business-management/site-search/wix-site-search/search.md
+import { siteSearch } from "@wix/search";
+import { wixModule } from "../sdk";
+import { imgSrc } from "../media";
+import { siteSearchPlan } from "./config.generated";
+import {
+  GROUP_LIMIT,
+  MIN_SUGGEST_CHARS,
+  MAX_SUGGEST_QUERY,
+  SUGGEST_LIMIT,
+  clampQuery,
+  federatedBody,
+  productsOf,
+  resolveConfig,
+  searchBody,
+  storeFrontById,
+  suggestBody,
+  toPage,
+  toSearchAll,
+  toSuggestGroups,
+  type Raw,
+} from "./search-core";
+import type { SearchAllResult, SearchOptions, SearchPage, SiteSearchConfig, SuggestGroup } from "./types";
+
+const search = wixModule(siteSearch);
+
+/** The plan's siteSearch entry resolved — types in order, routes, labels. */
+export const config: SiteSearchConfig = resolveConfig(siteSearchPlan);
+
+// The store-front pass is a second request that only adds product slugs and media; when it fails the
+// products render unlinked instead of failing the search.
+async function storeFrontPass(run: () => Promise<Raw>): Promise<Raw | null> {
+  try {
+    return await run();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Every configured type at once, `limit` hits per type — the grouped results page.
+ * Products are fetched twice (default format for title and highlights, store-front for the slug,
+ * see search-core) and joined on id. Empty `q` → no request, `indexed: null`.
+ */
+export async function searchAll(q: string, { limit = GROUP_LIMIT }: { limit?: number } = {}): Promise<SearchAllResult> {
+  const query = clampQuery(q);
+  if (!query) return { groups: [], indexed: null };
+  const wantsProducts = config.types.includes("products");
+  const [res, sf] = await Promise.all([
+    search.federatedSearch(federatedBody(query, config, { limit }) as siteSearch.FederatedSearchOptions),
+    wantsProducts ? storeFrontPass(() => search.federatedSearch(federatedBody(query, config, { limit, types: ["products"], storeFront: true }) as siteSearch.FederatedSearchOptions)) : null,
+  ]);
+  return toSearchAll(res.results as Raw[], config, imgSrc, storeFrontById(productsOf(sf?.results as Raw[] | undefined)));
+}
+
+/** One type with paging, ordering, filter and facets — the "show all" view and its pages. */
+export async function searchType(o: SearchOptions): Promise<SearchPage> {
+  const query = clampQuery(o.q);
+  if (!query) return toPage(null, o, config, imgSrc);
+  const [res, sf] = await Promise.all([
+    search.search(searchBody({ ...o, q: query }, config) as siteSearch.SearchOptions),
+    o.type === "products" ? storeFrontPass(() => search.search(searchBody({ ...o, q: query }, config, { storeFront: true }) as siteSearch.SearchOptions)) : null,
+  ]);
+  return toPage(res as Raw, { ...o, q: query }, config, imgSrc, storeFrontById(sf?.documents as Raw[] | undefined));
+}
+
+/** Suggestions for a partial phrase (3 to 50 chars; fewer → [] without a request), `limit` per type. */
+export async function suggest(q: string, { limit = SUGGEST_LIMIT }: { limit?: number } = {}): Promise<SuggestGroup[]> {
+  const query = clampQuery(q, MAX_SUGGEST_QUERY);
+  if (query.length < MIN_SUGGEST_CHARS) return [];
+  const res = await search.federatedSuggest(suggestBody(query, config, limit) as siteSearch.FederatedSuggestOptions);
+  return toSuggestGroups(res.results as Raw[], config, imgSrc);
+}

package/skills/wix-headless-templates/shared/capabilities/site-search/app/wix/site-search/suggest-store.ts

@@ -0,0 +1,178 @@
+// The header search box as a framework-free store — the logic behind useSuggest. Same shape as the
+// other stores: state, actions, subscribe/getState, emit after every change.
+//
+// THE debounce boundary of the capability lives here (the only timer): setInput() waits
+// `debounceMs` after the last keystroke, then asks for suggestions when the phrase has at least
+// `minChars` (the service's minimum is 3); a shorter phrase clears the list and cancels whatever is
+// in flight. A late response from a superseded phrase is dropped. Keyboard state (open, the active
+// row) is here too, so the component only renders and routes.
+//
+// submit() is the widget rule: an active row navigates to the row (a row without an href — a
+// product suggestion, whose slug the suggest service cannot return — becomes a search for its title
+// in its type); no active row → the results page for the typed phrase. The caller routes.
+import { suggest } from "./search";
+import { MAX_SUGGEST_QUERY, MIN_SUGGEST_CHARS, SUGGEST_DEBOUNCE_MS, SUGGEST_LIMIT, clampQuery } from "./search-core";
+import type { SearchDocType, SuggestGroup, SuggestHit } from "./types";
+
+export interface SuggestStoreOptions {
+  minChars?: number;
+  debounceMs?: number;
+  /** Suggestions per type (default 4). */
+  limit?: number;
+}
+
+export interface SuggestState {
+  /** What the input shows (untrimmed). */
+  input: string;
+  groups: SuggestGroup[];
+  /** The groups' hits flattened — the keyboard walks this. */
+  rows: SuggestHit[];
+  /** Whether the listbox is shown (rows exist and the box was not closed). */
+  open: boolean;
+  /** Index into rows; -1 = none. */
+  activeIndex: number;
+  loading: boolean;
+  error: string | null;
+}
+
+export type SuggestSubmit =
+  | { kind: "hit"; hit: SuggestHit; href: string }
+  | { kind: "query"; q: string; type: SearchDocType | null }
+  | null;
+
+export interface SuggestStore {
+  getState(): SuggestState;
+  subscribe(listener: () => void): () => void;
+  /** Every keystroke. Schedules the request; clears when under minChars. */
+  setInput(value: string): void;
+  /** Show the list again after a hide (focus). */
+  show(): void;
+  /** Hide the list and drop the active row (blur, Escape, a navigation). */
+  hide(): void;
+  /** Move the active row by ±1, wrapping; opens the list. */
+  moveActive(delta: number): void;
+  setActive(index: number): void;
+  /** What Enter (or the form submit) means right now; null when there is nothing to search. */
+  submit(): SuggestSubmit;
+  /** Cancel the timer and any in-flight request (unmount). */
+  stop(): void;
+}
+
+export function createSuggestStore({ minChars = MIN_SUGGEST_CHARS, debounceMs = SUGGEST_DEBOUNCE_MS, limit = SUGGEST_LIMIT }: SuggestStoreOptions = {}): SuggestStore {
+  let input = "";
+  let groups: SuggestGroup[] = [];
+  let rows: SuggestHit[] = [];
+  let closed = false;
+  let activeIndex = -1;
+  let loading = false;
+  let error: string | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let generation = 0;
+  const listeners = new Set<() => void>();
+  let snapshot: SuggestState | null = null;
+  const emit = () => {
+    snapshot = null;
+    for (const fn of listeners) fn();
+  };
+
+  function getState(): SuggestState {
+    if (snapshot) return snapshot;
+    snapshot = { input, groups, rows, open: !closed && rows.length > 0, activeIndex, loading, error };
+    return snapshot;
+  }
+
+  const clearTimer = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+
+  function setResults(next: SuggestGroup[]): void {
+    groups = next;
+    rows = next.flatMap((g) => g.hits);
+    if (activeIndex >= rows.length) activeIndex = -1;
+  }
+
+  function fetchNow(phrase: string): void {
+    const id = ++generation;
+    loading = true;
+    error = null;
+    emit();
+    suggest(phrase, { limit })
+      .then((res) => {
+        if (generation !== id) return; // superseded — drop it
+        setResults(res);
+        loading = false;
+        emit();
+      })
+      .catch((e) => {
+        if (generation !== id) return;
+        setResults([]);
+        loading = false;
+        error = e instanceof Error ? e.message : String(e);
+        emit();
+      });
+  }
+
+  return {
+    getState,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    setInput(value) {
+      input = value;
+      closed = false;
+      activeIndex = -1;
+      clearTimer();
+      const phrase = clampQuery(value, MAX_SUGGEST_QUERY);
+      if (phrase.length < Math.max(minChars, MIN_SUGGEST_CHARS)) {
+        generation++; // drop anything in flight
+        setResults([]);
+        loading = false;
+        error = null;
+        emit();
+        return;
+      }
+      emit();
+      timer = setTimeout(() => {
+        timer = null;
+        fetchNow(phrase);
+      }, debounceMs);
+    },
+    show() {
+      if (!closed) return;
+      closed = false;
+      emit();
+    },
+    hide() {
+      if (closed && activeIndex === -1) return;
+      closed = true;
+      activeIndex = -1;
+      emit();
+    },
+    moveActive(delta) {
+      if (!rows.length) return;
+      closed = false;
+      const n = rows.length;
+      activeIndex = activeIndex === -1 ? (delta > 0 ? 0 : n - 1) : (((activeIndex + delta) % n) + n) % n;
+      emit();
+    },
+    setActive(index) {
+      const next = index >= 0 && index < rows.length ? index : -1;
+      if (next === activeIndex) return;
+      activeIndex = next;
+      emit();
+    },
+    submit() {
+      const hit = !closed && activeIndex >= 0 ? rows[activeIndex] : undefined;
+      if (hit) return hit.href ? { kind: "hit", hit, href: hit.href } : { kind: "query", q: hit.title, type: hit.type };
+      const q = clampQuery(input);
+      return q ? { kind: "query", q, type: null } : null;
+    },
+    stop() {
+      clearTimer();
+      generation++;
+      loading = false;
+    },
+  };
+}

package/skills/wix-headless-templates/shared/capabilities/site-search/app/wix/site-search/types.ts

@@ -0,0 +1,158 @@
+// Site Search DTOs — the serializable shapes every hook, component and page consumes. Plain JSON:
+// safe as Astro island props and across a server/client boundary. `titleHtml` and `excerptHtml`
+// carry text and <mark> only (sanitised once, in search-core); `href` is a route of THIS site — the
+// `url` the index carries points at Wix pages a headless site does not have, and never leaves the
+// data layer.
+
+/** Our group keys. The Wix spelling of each ("public/stores/products", …) lives in search-core. */
+export type SearchDocType = "products" | "services" | "posts" | "events" | "pages";
+
+interface HitBase {
+  id: string;
+  type: SearchDocType;
+  /** Plain text — aria-labels, <title>, the fallback when there is no highlight. */
+  title: string;
+  /** The title with the matched words wrapped in <mark>; text and <mark> only. */
+  titleHtml: string;
+  /** The best highlighted passage of the description, else its start; text and <mark> only. "" when none. */
+  excerptHtml: string;
+  /** Resolved https URL ("" when the document has no image). */
+  imageUrl: string;
+  /** This site's route for the hit ("" when no slug could be derived — render the row unlinked). */
+  href: string;
+}
+
+export interface ProductHit extends HitBase {
+  type: "products";
+  slug: string;
+  /** Formatted, as the index carries it ("€54.99"); "" when absent. */
+  price: string;
+  inStock: boolean;
+  collections: string[];
+}
+export interface ServiceHit extends HitBase {
+  type: "services";
+  slug: string;
+  category: string;
+  tagLine: string;
+}
+export interface PostHit extends HitBase {
+  type: "posts";
+  slug: string;
+  /** ISO date; "" when absent. */
+  publishDate: string;
+  author: string;
+  tags: string[];
+}
+export interface EventHit extends HitBase {
+  type: "events";
+  slug: string;
+  /** ISO date; "" when absent. */
+  startDate: string;
+  location: string;
+  /** Formatted lowest ticket price ("From €20"), "Free", or "" when unknown. */
+  price: string;
+}
+/** Wix-page content — a headless site has none; off by default (the plan may turn it on). */
+export interface PageHit extends HitBase {
+  type: "pages";
+}
+export type SearchHit = ProductHit | ServiceHit | PostHit | EventHit | PageHit;
+
+/** One document type's slice of a federated search. */
+export interface SearchGroup {
+  type: SearchDocType;
+  label: string;
+  /** Matching documents of this type across the whole index — usually more than `hits` holds. */
+  total: number;
+  hits: SearchHit[];
+}
+
+export interface FacetValue {
+  value: string;
+  count: number;
+}
+export interface SearchFacets {
+  /** Term facets by field name (products: `collections`, `inStock`). */
+  terms: Record<string, FacetValue[]>;
+  /** Numeric bounds by field name (products: `discountedPriceNumeric`). */
+  ranges: Record<string, { min: number | null; max: number | null }>;
+}
+
+export type SearchSort = "relevance" | "price-asc" | "price-desc" | "date-desc";
+
+export interface SearchFilter {
+  /** Products: any of these collection names. */
+  collections?: string[];
+  /** Products: in stock only. */
+  inStockOnly?: boolean;
+  /** Products: discounted price bounds. */
+  minPrice?: number;
+  maxPrice?: number;
+}
+
+/** A single-type query — the results page's "show all" view and its pages. */
+export interface SearchOptions {
+  q: string;
+  type: SearchDocType;
+  /** 1–100, default 12. */
+  limit?: number;
+  offset?: number;
+  sort?: SearchSort;
+  filter?: SearchFilter;
+  /** Typo tolerance (default from the config). */
+  fuzzy?: boolean;
+}
+
+export interface SearchPage {
+  type: SearchDocType;
+  hits: SearchHit[];
+  total: number;
+  offset: number;
+  limit: number;
+  hasNext: boolean;
+  facets: SearchFacets;
+}
+
+export interface SearchAllResult {
+  /** Non-empty groups in the configured type order. */
+  groups: SearchGroup[];
+  /**
+   * Whether the site has an index at all. true: documents came back. false: the response listed no
+   * document type — nothing is indexed (the Wix Site Search app is not installed on this site).
+   * null: unknown — zero documents is ambiguous (no match, an empty catalog, or an index still
+   * back-filling after the install); do not read it as "not installed".
+   */
+  indexed: boolean | null;
+}
+
+export type SuggestHit = Pick<SearchHit, "id" | "type" | "title" | "titleHtml" | "imageUrl" | "href">;
+
+export interface SuggestGroup {
+  type: SearchDocType;
+  label: string;
+  hits: SuggestHit[];
+}
+
+/** The resolved configuration every call reads (search-core's resolveConfig, from the plan). */
+export interface SiteSearchConfig {
+  /** Document types searched and shown, in this order. */
+  types: SearchDocType[];
+  /** Route templates per type, `[slug]` replaced by the URL-encoded slug. "" = never linked. */
+  routes: Record<SearchDocType, string>;
+  labels: Record<SearchDocType, string>;
+  /** BCP-47 language the index is queried in; null lets the service pick. */
+  language: string | null;
+  fuzzy: boolean;
+}
+
+/** What `plan.capabilities.siteSearch` may say — deploy writes it to config.generated.ts as data. */
+export interface SiteSearchPlan {
+  /** Install the Wix Site Search app during the seed (the capability's seed/install.mjs). */
+  install?: boolean;
+  types?: string[];
+  routes?: Record<string, string>;
+  labels?: Record<string, string>;
+  language?: string;
+  fuzzy?: boolean;
+}

package/skills/wix-headless-templates/shared/capabilities/site-search/app-astro/pages/search.astro

@@ -0,0 +1,33 @@
+---
+// The results page: /search?q=<phrase>[&type=<products|services|posts|events>].
+//
+// SSR renders the first result set from the query string — the grouped view (every configured type
+// at once) or, with `type`, the first page of that type — and hands it to the SearchResults island,
+// which takes over: "show all", sort, facets, paging, all client-side against the same data layer.
+// Keep the frontmatter (the clamp to 100 chars, the type check against the config, the noindex
+// header); restyle the template. SiteLayout is the deployed vertical's — brand it there; the header
+// SearchBox (components/site-search/SearchBox.tsx, client:only="react") is what leads visitors here.
+import SiteLayout from "../layouts/SiteLayout.astro";
+import SearchResults from "../components/site-search/SearchResults";
+import { config, searchAll, searchType } from "../wix/site-search/search";
+import { MAX_QUERY, clampQuery, isDocType } from "../wix/site-search/search-core";
+import type { SearchAllResult, SearchPage } from "../wix/site-search/types";
+
+const q = clampQuery(Astro.url.searchParams.get("q"), MAX_QUERY);
+const typeParam = Astro.url.searchParams.get("type");
+const type = isDocType(typeParam) && config.types.includes(typeParam) ? typeParam : null;
+
+// A search page is never a landing page: keep it out of the index (the header form works with every
+// layout, where a <meta> in the seo-tags slot would fight the layout's own <title>).
+Astro.response.headers.set("X-Robots-Tag", "noindex");
+
+// Fail loudly on a real error (the layout's error page), but an empty q renders the prompt state.
+let initial: SearchAllResult | null = null;
+let initialPage: SearchPage | null = null;
+if (q && !type) initial = await searchAll(q);
+if (q && type) initialPage = await searchType({ q, type });
+---
+
+<SiteLayout title={q ? `Search: ${q}` : "Search"} description={q ? `Search results for “${q}”` : "Search this site"}>
+  <SearchResults client:load q={q} type={type} initialGroups={initial?.groups ?? null} initialIndexed={initial?.indexed ?? null} initialPage={initialPage} />
+</SiteLayout>