@syntrologie/adapt-search 2.8.0-canary.568

package/dist/hrefSafety.d.ts

@@ -0,0 +1,32 @@
+/**
+ * adaptive-search — product URL scheme guard
+ *
+ * Same rule and same reasoning as `isSafeNavigationHref` in
+ * `packages/adaptives/adaptive-overlays/src/cta-navigation.ts`: parse with the
+ * URL parser rather than matching string prefixes, because browsers strip
+ * embedded control characters from a scheme before resolving it, so
+ * `"java\tscript:alert(1)"` slips straight past a
+ * `.trim().toLowerCase().startsWith('javascript:')` check.
+ *
+ * It is copied rather than imported because that helper is internal to
+ * adaptive-overlays (its package `exports` publish only `./runtime`,
+ * `./schema` and `./cdn`), and every adaptive in this repo keeps its own
+ * sanitizer for the same reason — see `adaptive-product/src/sanitizer.ts`,
+ * `adaptive-overlays/src/sanitizer.ts`, `adaptive-content/src/sanitizer.ts`.
+ */
+/** Where an unsafe or unparseable product URL points instead: nowhere. */
+export declare const UNSAFE_HREF_FALLBACK = "#";
+/** True when `href` resolves to a scheme it is safe to navigate to. */
+export declare function isSafeProductHref(href: unknown): href is string;
+/**
+ * The href to render for a product tile: the authored URL when its scheme is
+ * safe, otherwise `'#'`.
+ *
+ * The tile keeps its anchor either way. A shopper who can reach a tile with
+ * the keyboard must still be able to focus it and hear its name, and a tile
+ * whose link we silently dropped is a tile that looks tappable and is not.
+ * Callers mark the fallback case with `data-unsafe-url` so it is visible in
+ * the DOM rather than looking like an ordinary link.
+ */
+export declare function safeProductHref(href: unknown): string;
+//# sourceMappingURL=hrefSafety.d.ts.map

package/dist/hrefSafety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hrefSafety.d.ts","sourceRoot":"","sources":["../src/hrefSafety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAW/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAErD"}

package/dist/regions.d.ts

@@ -0,0 +1,93 @@
+/**
+ * adaptive-search — region modules
+ *
+ * One function per module the plan can put in a region. Everything here is
+ * rendered with Lit `${}` interpolation only: never `unsafeHTML`, because
+ * every string on this surface is either shopper-authored (the query, the
+ * chips) or merchant catalogue text arriving over the wire.
+ *
+ * A module this build does not know renders nothing and throws nothing. The
+ * plan service ships new modules on its own cadence; an older SDK on a
+ * merchant's page must degrade to a quieter surface, never to a broken one.
+ */
+import { nothing, type TemplateResult } from 'lit';
+import type { SurfaceRegion } from './variants';
+/** A product as the plan service and the store search API both describe one. */
+export interface SearchProduct {
+    handle: string;
+    title: string;
+    url: string;
+    price?: string;
+    imageUrl?: string;
+}
+/** A constraint the surface understood, shown as a removable chip. */
+export interface SearchChip {
+    key: string;
+    label: string;
+}
+/** A follow-up the plan suggests, shown as a tappable button. */
+export interface SearchSuggestion {
+    value: string;
+    label: string;
+}
+/** Follow-up bar payload: the shopper's words, what we understood, what next. */
+export interface FollowupBarPayload {
+    query?: string;
+    chips?: SearchChip[];
+    suggestions?: SearchSuggestion[];
+    /**
+     * A short line the plan wants under the chips, e.g. "Nothing under $5. Here
+     * are the closest matches." Merchant-neutral server prose, interpolated like
+     * every other string here and never `unsafeHTML`.
+     */
+    notice?: string;
+}
+/** How a tile reports itself when it is tapped. */
+export interface ResultTapDetail {
+    handle: string;
+    regionId: string;
+    module: string;
+    position: number;
+}
+/** The three shapes a follow-up takes. All patch the same server session. */
+export type FollowupDetail = {
+    kind: 'refine';
+    value: string;
+} | {
+    kind: 'chip_removed';
+    value: string;
+} | {
+    kind: 'item_dismissed';
+    value: string;
+};
+export declare const RESULT_TAP_EVENT = "syntro:search:result-tap";
+export declare const FOLLOWUP_EVENT = "syntro:search:followup";
+export declare const SEE_STORE_RESULTS_EVENT = "syntro:search:see-store-results";
+/** Read the follow-up bar's payload. Exported so the surface can merge the query in. */
+export declare function readFollowupBarPayload(payload: unknown): Required<FollowupBarPayload>;
+/**
+ * Handles the shopper has hidden. A dismissal is optimistic — the tile goes as
+ * soon as it is tapped, before any server round trip — and it OUTLIVES the
+ * payload it was tapped in: a later repaint of the same region, or a whole new
+ * plan for a surface with no server session, would otherwise hand the shopper
+ * back the product they just rejected.
+ *
+ * `visible` / `visibleOne` below apply this to what is RENDERED, which is what
+ * hides a tile in a region that has already painted and is not repainted. The
+ * runtime keeps the same rule over incoming payloads — `withoutDismissed` in
+ * `runtime-sdk/src/search/SearchSurfaceController.ts` — so a dismissed product
+ * is also out of `result_count`. Both are needed; neither replaces the other.
+ */
+export type DismissedHandles = ReadonlySet<string>;
+/**
+ * How many products a filled region put on screen. The surface announces the
+ * running total through its live region, so this has to agree with what the
+ * module above actually rendered — dismissals included, because a hidden tile
+ * is not a result the shopper was shown.
+ */
+export declare function countRegionProducts(region: SurfaceRegion, dismissed?: DismissedHandles): number;
+/** Use the same payload readers as rendering to decide whether there is an answer. */
+export declare function regionHasAnswer(region: SurfaceRegion, dismissed?: DismissedHandles): boolean;
+/** Render a region's module. An unknown module renders nothing and throws nothing. */
+export declare function renderRegionModule(region: SurfaceRegion, dismissed?: DismissedHandles): TemplateResult | typeof nothing;
+//# sourceMappingURL=regions.d.ts.map

package/dist/regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regions.d.ts","sourceRoot":"","sources":["../src/regions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAQ,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,sEAAsE;AACtE,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAM9C,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AAC3D,eAAO,MAAM,cAAc,2BAA2B,CAAC;AACvD,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AA8DzE,wFAAwF;AACxF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAQrF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAiBnD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,gBAAiC,GAC3C,MAAM,CAqBR;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,gBAAiC,GAC3C,OAAO,CAKT;AA+ND,sFAAsF;AACtF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,gBAAiC,GAC3C,cAAc,GAAG,OAAO,OAAO,CA0BjC"}

package/dist/runtime.d.ts

@@ -0,0 +1,45 @@
+/**
+ * adaptive-search — Runtime manifest
+ *
+ * Registers `<syntro-search-surface>` as a side effect of importing this
+ * module, and exposes the mountable the runtime's WidgetRegistry uses.
+ */
+import { type MountPlumbing } from '@syntrologie/sdk-contracts';
+import type { SearchSurfaceConfig } from './schema';
+/**
+ * Mounts the surface and, when the interceptor already chose a variant,
+ * paints its skeleton in the same frame. Later tasks keep the element handle
+ * and stream regions into it with `fillRegion`.
+ */
+export declare const SearchSurfaceMountable: {
+    mount(container: HTMLElement, config?: (SearchSurfaceConfig & MountPlumbing) | null): () => void;
+};
+export declare const runtime: {
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    /** No DOM-mutation executors: this surface renders only. */
+    executors: never[];
+    widgets: {
+        id: string;
+        component: {
+            mount(container: HTMLElement, config?: (SearchSurfaceConfig & MountPlumbing) | null): () => void;
+        };
+        metadata: {
+            name: string;
+            description: string;
+            icon: string;
+            /**
+             * The surface replaces a whole results page, so it needs the
+             * full-viewport slot. It is not self-sufficient anywhere else: the
+             * scrolling and scroll containment it relies on come from
+             * `overlay_full`'s own slot styles (`overflow: auto` plus
+             * `overscroll-behavior: contain`), not from this element.
+             */
+            slots: string[];
+        };
+    }[];
+};
+export default runtime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAsB,MAAM,4BAA4B,CAAC;AAGpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAIpD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;qBAChB,WAAW,WAAW,CAAC,mBAAmB,GAAG,aAAa,CAAC,GAAG,IAAI;CASpF,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;IAMlB,4DAA4D;;;;;6BAjB3C,WAAW,WAAW,CAAC,mBAAmB,GAAG,aAAa,CAAC,GAAG,IAAI;;;;;;YA4B7E;;;;;;eAMG;;;;CAKV,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,12 @@
+import {
+  SearchSurfaceMountable,
+  runtime,
+  runtime_default
+} from "./chunk-3KPQ5AOG.js";
+import "./chunk-NKOTQPVZ.js";
+export {
+  SearchSurfaceMountable,
+  runtime_default as default,
+  runtime
+};
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/schema.d.ts

@@ -0,0 +1,49 @@
+/**
+ * adaptive-search — Zod schema and capabilities documentation
+ *
+ * The surface is driven by the plan service at runtime, not authored as a
+ * canvas tile, so the only config it accepts is the opening state the search
+ * interceptor hands it at mount: which variant the rules chose and what the
+ * shopper typed. Everything after that arrives through `fillRegion`.
+ */
+import { z } from 'zod';
+export declare const searchSurfaceSchema: z.ZodObject<{
+    variant: z.ZodOptional<z.ZodEnum<["grid", "stacked", "rail", "hero", "compare"]>>;
+    query: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    query?: string | undefined;
+    variant?: "grid" | "stacked" | "rail" | "hero" | "compare" | undefined;
+}, {
+    query?: string | undefined;
+    variant?: "grid" | "stacked" | "rail" | "hero" | "compare" | undefined;
+}>;
+export type SearchSurfaceConfig = z.infer<typeof searchSurfaceSchema>;
+/**
+ * No tile widgets: this surface is not something a config author places on a
+ * page. It is mounted by the search interceptor into the full-viewport
+ * overlay slot when a shopper searches.
+ */
+export declare const tileWidgets: {
+    widget: string;
+    defName: string;
+    propsSchema: z.ZodTypeAny;
+}[];
+export declare const CAPABILITIES_DOCUMENTATION: {
+    packageId: string;
+    plannerSummary: string;
+    description: string;
+    whenToUse: {
+        goal: string;
+        action: string;
+    }[];
+    conventions: {
+        name: string;
+        description: string;
+    }[];
+    events: {
+        name: string;
+        when: string;
+        props: string;
+    }[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,mBAAmB;;;;;;;;;EAcrB,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,CAAC,CAAC,UAAU,CAAC;CAC3B,EAAO,CAAC;AAMT,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;CAoDtC,CAAC"}

package/dist/schema.js

@@ -0,0 +1,66 @@
+import {
+  SURFACE_VARIANTS,
+  external_exports
+} from "./chunk-NKOTQPVZ.js";
+
+// src/schema.ts
+var MAX_QUERY_LENGTH = 512;
+var searchSurfaceSchema = external_exports.object({
+  variant: external_exports.enum(SURFACE_VARIANTS).optional().describe(
+    "Layout to paint immediately: grid, stacked, rail, hero or compare. Omit to mount an empty surface and wait for the plan."
+  ),
+  query: external_exports.string().max(MAX_QUERY_LENGTH).optional().describe("The shopper's own words, shown in the follow-up bar and still editable.")
+}).strict();
+var tileWidgets = [];
+var CAPABILITIES_DOCUMENTATION = {
+  packageId: "adaptive-search",
+  plannerSummary: "The search results surface. Reach for this when the strategy is about what a shopper sees after they search, not about placing a tile on a page.",
+  description: "Draws a search results page as a Syntro surface: a layout skeleton painted per variant, then filled region by region as content arrives.",
+  whenToUse: [
+    {
+      goal: "Turn on the search takeover for a workspace",
+      action: "Set search.enabled to true in the config. The surface mounts itself when a shopper searches."
+    },
+    {
+      goal: "Watch searches without changing what a shopper sees",
+      action: "Set search.observe to true instead. Telemetry is emitted and the store\u2019s own search still runs."
+    }
+  ],
+  conventions: [
+    {
+      name: "The plan chooses contents, never shape",
+      description: "Each variant owns a fixed set of named regions. The plan service fills them by region id; it cannot invent a region or move one."
+    },
+    {
+      name: "Theme tokens",
+      description: "The surface reads CSS custom properties from the canvas theme: --sc-color-primary, --sc-font-family, --sc-tile-background, --sc-tile-text-color, --sc-chip-background, --sc-border-radius. It hard-codes no brand colors."
+    },
+    {
+      name: "The way back to the store",
+      description: 'Every variant carries a "See store results" button in its sticky query region, so a shopper can always reach the store\u2019s own results.'
+    }
+  ],
+  events: [
+    {
+      name: "syntro:search:followup",
+      when: "Shopper refines the search: types a new query, removes a chip, or dismisses a product",
+      props: "{ kind: 'refine' | 'chip_removed' | 'item_dismissed', value }"
+    },
+    {
+      name: "syntro:search:result-tap",
+      when: "Shopper taps a product tile",
+      props: "{ handle, regionId, module, position }"
+    },
+    {
+      name: "syntro:search:see-store-results",
+      when: "Shopper asks for the store's own search results instead",
+      props: "{}"
+    }
+  ]
+};
+export {
+  CAPABILITIES_DOCUMENTATION,
+  searchSurfaceSchema,
+  tileWidgets
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/schema.ts"],
+  "sourcesContent": ["/**\n * adaptive-search \u2014 Zod schema and capabilities documentation\n *\n * The surface is driven by the plan service at runtime, not authored as a\n * canvas tile, so the only config it accepts is the opening state the search\n * interceptor hands it at mount: which variant the rules chose and what the\n * shopper typed. Everything after that arrives through `fillRegion`.\n */\n\nimport { z } from 'zod';\n\nimport { SURFACE_VARIANTS } from './variants';\n\n/** The classifier stops reading a query here, so nothing longer can be real. */\nconst MAX_QUERY_LENGTH = 512;\n\nexport const searchSurfaceSchema = z\n  .object({\n    variant: z\n      .enum(SURFACE_VARIANTS)\n      .optional()\n      .describe(\n        'Layout to paint immediately: grid, stacked, rail, hero or compare. Omit to mount an empty surface and wait for the plan.'\n      ),\n    query: z\n      .string()\n      .max(MAX_QUERY_LENGTH)\n      .optional()\n      .describe(\"The shopper's own words, shown in the follow-up bar and still editable.\"),\n  })\n  .strict();\n\nexport type SearchSurfaceConfig = z.infer<typeof searchSurfaceSchema>;\n\n/**\n * No tile widgets: this surface is not something a config author places on a\n * page. It is mounted by the search interceptor into the full-viewport\n * overlay slot when a shopper searches.\n */\nexport const tileWidgets: {\n  widget: string;\n  defName: string;\n  propsSchema: z.ZodTypeAny;\n}[] = [];\n\n// ============================================================================\n// Capabilities Documentation (injected into JSON Schema for LLM prompts)\n// ============================================================================\n\nexport const CAPABILITIES_DOCUMENTATION = {\n  packageId: 'adaptive-search',\n  plannerSummary:\n    'The search results surface. Reach for this when the strategy is about what a shopper sees after they search, not about placing a tile on a page.',\n  description:\n    'Draws a search results page as a Syntro surface: a layout skeleton painted per variant, then filled region by region as content arrives.',\n  whenToUse: [\n    {\n      goal: 'Turn on the search takeover for a workspace',\n      action:\n        'Set search.enabled to true in the config. The surface mounts itself when a shopper searches.',\n    },\n    {\n      goal: 'Watch searches without changing what a shopper sees',\n      action:\n        'Set search.observe to true instead. Telemetry is emitted and the store\u2019s own search still runs.',\n    },\n  ],\n  conventions: [\n    {\n      name: 'The plan chooses contents, never shape',\n      description:\n        'Each variant owns a fixed set of named regions. The plan service fills them by region id; it cannot invent a region or move one.',\n    },\n    {\n      name: 'Theme tokens',\n      description:\n        'The surface reads CSS custom properties from the canvas theme: --sc-color-primary, --sc-font-family, --sc-tile-background, --sc-tile-text-color, --sc-chip-background, --sc-border-radius. It hard-codes no brand colors.',\n    },\n    {\n      name: 'The way back to the store',\n      description:\n        'Every variant carries a \"See store results\" button in its sticky query region, so a shopper can always reach the store\u2019s own results.',\n    },\n  ],\n  events: [\n    {\n      name: 'syntro:search:followup',\n      when: 'Shopper refines the search: types a new query, removes a chip, or dismisses a product',\n      props: \"{ kind: 'refine' | 'chip_removed' | 'item_dismissed', value }\",\n    },\n    {\n      name: 'syntro:search:result-tap',\n      when: 'Shopper taps a product tile',\n      props: '{ handle, regionId, module, position }',\n    },\n    {\n      name: 'syntro:search:see-store-results',\n      when: \"Shopper asks for the store's own search results instead\",\n      props: '{}',\n    },\n  ],\n};\n"],
+  "mappings": ";;;;;;AAcA,IAAM,mBAAmB;AAElB,IAAM,sBAAsB,iBAChC,OAAO;AAAA,EACN,SAAS,iBACN,KAAK,gBAAgB,EACrB,SAAS,EACT;AAAA,IACC;AAAA,EACF;AAAA,EACF,OAAO,iBACJ,OAAO,EACP,IAAI,gBAAgB,EACpB,SAAS,EACT,SAAS,yEAAyE;AACvF,CAAC,EACA,OAAO;AASH,IAAM,cAIP,CAAC;AAMA,IAAM,6BAA6B;AAAA,EACxC,WAAW;AAAA,EACX,gBACE;AAAA,EACF,aACE;AAAA,EACF,WAAW;AAAA,IACT;AAAA,MACE,MAAM;AAAA,MACN,QACE;AAAA,IACJ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,QACE;AAAA,IACJ;AAAA,EACF;AAAA,EACA,aAAa;AAAA,IACX;AAAA,MACE,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,EACF;AAAA,EACA,QAAQ;AAAA,IACN;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/variants.d.ts

@@ -0,0 +1,52 @@
+/**
+ * adaptive-search — layout variants
+ *
+ * A variant declares the fixed set of named regions the surface paints. The
+ * plan chooses what goes IN each region; it never chooses the shape. That
+ * split is what lets the surface paint a skeleton the instant the shopper
+ * presses Enter, before a single byte of content has arrived.
+ *
+ * `src/__fixtures__/search-variant-roles.json` is the wire contract: the
+ * plan service keeps a byte-equal copy and asserts against this path, so the
+ * region ids the server emits always resolve to a region this surface owns.
+ */
+/** The five layouts. Same values as the SDK classifier's `SearchVariantHint`. */
+export declare const SURFACE_VARIANTS: readonly ["grid", "stacked", "rail", "hero", "compare"];
+export type SurfaceVariant = (typeof SURFACE_VARIANTS)[number];
+/** What a region is FOR. A module fills it; the role decides where it sits. */
+export type RegionRole = 'query' | 'primary' | 'secondary' | 'support' | 'converse';
+/** One painted region: an id the plan addresses, a role, and the module inside. */
+export interface SurfaceRegion {
+    id: string;
+    role: RegionRole;
+    module: string;
+    payload?: unknown;
+}
+/** A server plan: the variant to paint and the regions to fill. */
+export interface SurfacePlan {
+    variant: SurfaceVariant;
+    regions: SurfaceRegion[];
+    suppress?: string[];
+}
+/** The fixed slots each variant owns. The plan chooses contents, never shape. */
+export declare const VARIANT_REGION_ROLES: Record<SurfaceVariant, readonly RegionRole[]>;
+/** A region slot in the painted skeleton: `<role>-<n>`, n restarting per role. */
+export interface SkeletonRegion {
+    id: string;
+    role: RegionRole;
+}
+/**
+ * The region slots a variant paints, in paint order, with deterministic ids.
+ *
+ * Deterministic because the plan service numbers its regions the same way and
+ * addresses them by id alone. Derived from `VARIANT_REGION_ROLES` rather than
+ * listed a second time, so the two can never disagree.
+ */
+export declare function skeletonRegions(variant: SurfaceVariant): SkeletonRegion[];
+/**
+ * True when every region in the plan has a slot of its role left in the
+ * variant. A plan that does not fit is a plan whose extra regions would paint
+ * nowhere, which is worse than painting the variant the plan asked for.
+ */
+export declare function planRegionsFit(plan: SurfacePlan): boolean;
+//# sourceMappingURL=variants.d.ts.map

package/dist/variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../src/variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,yDAA0D,CAAC;AAExF,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,+EAA+E;AAC/E,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAEpF,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,cAAc,EAAE,SAAS,UAAU,EAAE,CAM9E,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,CAOzE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAQzD"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@syntrologie/adapt-search",
+  "version": "2.8.0-canary.568",
+  "description": "Adaptive Search: the search results surface, a layout skeleton painted per variant and then filled region by region as content arrives.",
+  "license": "Proprietary",
+  "private": false,
+  "author": "Syntrologie <eng@syntrologie.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SyntropyForge/amazing-demos.git",
+    "directory": "packages/adaptives/adaptive-search"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "syntrologie": {
+    "bundlingMode": "cdn-only"
+  },
+  "type": "module",
+  "exports": {
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    },
+    "./cdn": {
+      "types": "./dist/cdn.d.ts",
+      "import": "./dist/cdn.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --emitDeclarationOnly && node ../scripts/build-lib.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check ."
+  },
+  "peerDependencies": {
+    "lit": "3.3.2"
+  },
+  "devDependencies": {
+    "@open-wc/testing": "4.0.0",
+    "@open-wc/testing-helpers": "3.0.1",
+    "@syntrologie/sdk-contracts": "*",
+    "jsdom": "26.1.0",
+    "lit": "3.3.2",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18",
+    "zod": "3.25.76"
+  }
+}