sbuilder-mcp 0.76.4 → 0.78.0

package/dist/catalog/appscaffolds.generated.js

@@ -7,7 +7,7 @@
  * platform's own order — read off `builtinapps.Keys` rather than typed here,
  * and checked at codegen against that route's own `key` parameter description.
  */
-export const BUILTIN_APP_KEYS = ["mail", "multilingual", "agent", "chat", "booking", "loyalty", "payments", "courses"];
+export const BUILTIN_APP_KEYS = ["mail", "multilingual", "agent", "chat", "booking", "loyalty", "payments", "courses", "shipping", "pos", "tickets"];
 /**
  * The pages an app needs that installing it does not create.
  *

package/dist/catalog/deadkeys.generated.js

@@ -1,7 +1,7 @@
 export const DEAD_KEY_SOURCE = {
-    "files": 4599,
-    "identifiers": 85994,
-    "seededKeys": 442,
+    "files": 5543,
+    "identifiers": 102115,
+    "seededKeys": 443,
     "dead": 0
 };
 /**

package/dist/catalog/element-search.js

@@ -1,4 +1,7 @@
-import { ELEMENTS, TRAIT_WRITES } from './elements.generated.js';
+import { ELEMENTS, TRAIT_WRITES, WRITE_PRECONDITIONS } from './elements.generated.js';
+import { FORM_TEMPLATES } from './checkout.generated.js';
+import { isBaseOnlyConfig } from '../domains/site/baseonly.js';
+import { bindableFields } from '../domains/site/writecheck.js';
 import { animationValues, animationVocabulary, elementVocabularies, sharedVocabularies, vocabulariesForWrites, } from '../domains/site/vocabulary.js';
 import { neverTranslatedOn, translatableSpecials } from '../domains/site/translate.js';
 /** Eight to choose from; the hints for the chosen one come with sb_traits_for. */
@@ -48,6 +51,94 @@ export function catalogBrowse() {
 export function largestCategorySize() {
     return Math.max(...Object.values(catalogBrowse()).map((g) => g.length));
 }
+/**
+ * Lowercase, diacritics off, camelCase and snake_case split — the unit a word
+ * match compares. `đ` is a LETTER, not a base plus a combining mark, so NFD
+ * leaves it whole and "đặt" used to split into nothing; it folds to `d` first.
+ */
+export function searchWords(s) {
+    return s
+        .replace(/đ/g, 'd')
+        .replace(/Đ/g, 'D')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+/** Two spellings of one name compare equal: "Product list", "product-list", "PRÓDUCT LÍST". */
+const slug = (s) => searchWords(s).join('-');
+/**
+ * CAPABILITY is the element's own generated config/specials keys and the
+ * vocabulary VALUES they take — so "pagination", "load_more" and "sort" find
+ * the element that does them from the shared metadata, with no alias table to
+ * drift. The weakest word signal, because a key name is not a purpose.
+ */
+let index = null;
+function searchIndex() {
+    return (index ??= Object.values(ELEMENTS).map((el) => {
+        const cap = [
+            ...Object.keys(el.defaults?.config ?? {}),
+            ...Object.keys(el.defaults?.specials ?? {}),
+            ...Object.values(elementVocabularies(el.type)).flatMap((v) => [v.writeKey, ...v.values]),
+        ];
+        const hints = [...el.semantics, ...el.useWhen];
+        // The element's own VIETNAMESE default copy ("Giờ hẹn", "Chọn một mục") —
+        // the only words a Vietnamese query can meet, since every hint is English.
+        // Non-ASCII strings only: an ASCII default is a value ("native", "future"), not copy.
+        const copy = Object.values(el.defaults?.specials ?? {}).filter((v) => typeof v === 'string' && /[^\x00-\x7f]/.test(v));
+        return {
+            el,
+            ix: {
+                type: el.type,
+                label: slug(el.label),
+                typeWords: new Set(searchWords(el.type)),
+                labelWords: new Set(searchWords(el.label)),
+                hintWords: new Set(searchWords(hints.join(' '))),
+                descWords: new Set(searchWords(`${el.category} ${el.description}`)),
+                capWords: new Set(searchWords(cap.join(' '))),
+                copyWords: new Set(searchWords(copy.join(' '))),
+                hay: searchWords([el.type, el.label, el.category, el.description, ...hints].join(' ')).join(' '),
+            },
+        };
+    }));
+}
+/** A whole word, or its plural — "image" finds "images" without a stemmer. */
+const has = (set, t) => set.has(t) || set.has(`${t}s`);
+/**
+ * Tiered, so a stronger signal is never outvoted by a pile of weaker ones:
+ * exact type > exact label > the type's own words > the label's > semantics and
+ * useWhen > description > capability > bare substring. Measured before this:
+ * "list" returned address-book first and not `list` at all, because a flat
+ * substring count over prose ranks whatever mentions a word most.
+ */
+function score(ix, q, terms) {
+    let s = 0;
+    if (ix.type === q)
+        s += 1e6;
+    if (ix.label === q)
+        s += 1e5;
+    if (ix.type.startsWith(q))
+        s += 1e4;
+    for (const t of terms) {
+        if (has(ix.typeWords, t))
+            s += 1000;
+        if (has(ix.labelWords, t))
+            s += 300;
+        if (has(ix.hintWords, t))
+            s += 30;
+        if (has(ix.descWords, t))
+            s += 10;
+        if (ix.copyWords.has(t))
+            s += 5;
+        if (has(ix.capWords, t))
+            s += 3;
+        if (ix.hay.includes(t))
+            s += 1;
+    }
+    return s;
+}
 /**
  * Four fields to CHOOSE by.
  *
@@ -57,14 +148,10 @@ export function largestCategorySize() {
  * `traitsFor` now carries. `detail: true` restores the hints per match.
  */
 export function catalogMatches(query, opts = {}) {
-    const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
-    return Object.values(ELEMENTS)
-        .map((el) => {
-        const hay = [el.type, el.label, el.category, el.description, ...el.semantics, ...el.useWhen]
-            .join(' ')
-            .toLowerCase();
-        return { el, score: terms.filter((t) => hay.includes(t)).length };
-    })
+    const terms = searchWords(query);
+    const q = terms.join('-');
+    return searchIndex()
+        .map(({ el, ix }) => ({ el, score: score(ix, q, terms) }))
         .filter((s) => s.score > 0)
         .sort((a, b) => b.score - a.score || a.el.type.localeCompare(b.el.type))
         .slice(0, opts.limit ?? DEFAULT_CATALOG_LIMIT)
@@ -80,10 +167,66 @@ export function catalogMatches(query, opts = {}) {
             : {}),
     }));
 }
+let templateIndex = null;
+/**
+ * THE PLATFORM'S FORM TEMPLATES, found the way an agent asks for them: "đặt
+ * lịch", "ngày nhận phòng". A booking form is not an element — it is a form
+ * document `sb_store action:"form"` seeds — so an element search alone sends
+ * the caller to hand-assemble one field at a time. Indexed on the key, the
+ * title, the submit text and every field label.
+ *
+ * Strict on purpose, because each one costs the caller tokens: a single word
+ * must BE the key ("booking"), and several words must ALL be in one template.
+ * "email" is on half of them and asks for none.
+ */
+export function formTemplateMatches(query, limit = 3) {
+    templateIndex ??= Object.values(FORM_TEMPLATES).map((t) => {
+        const nodes = Object.values(t.document.nodes);
+        const str = (v) => (typeof v === 'string' ? v : '');
+        const title = str(nodes.find((n) => n.data.type === 'form-title')?.specials?.text);
+        const copy = nodes.flatMap((n) => [str(n.specials?.label), str(n.specials?.text)]);
+        return {
+            key: t.key,
+            type: t.type,
+            title,
+            titleWords: new Set(searchWords(title)),
+            all: new Set(searchWords([t.key, ...copy].join(' '))),
+        };
+    });
+    const terms = searchWords(query);
+    if (terms.length === 0)
+        return [];
+    return templateIndex
+        .filter((t) => (terms.length === 1 ? t.key === terms[0] : terms.every((w) => t.all.has(w))))
+        .map((t) => ({ t, score: terms.filter((w) => t.titleWords.has(w)).length }))
+        .sort((a, b) => b.score - a.score || a.t.key.localeCompare(b.t.key))
+        .slice(0, limit)
+        .map(({ t }) => ({
+        template: t.key,
+        form_type: t.type,
+        title: t.title,
+        use: `sb_store action:"form" template:"${t.key}"`,
+    }));
+}
+/**
+ * Elements and templates in ONE ranking. A template whose TITLE holds every
+ * word of the query ("đặt lịch" → "Đặt lịch hẹn") is the answer the caller
+ * meant and goes first — unless an element's type IS the query, which always
+ * wins. Otherwise templates trail the elements, as before.
+ */
+export function searchWithTemplates(query, elements) {
+    const templates = formTemplateMatches(query);
+    const terms = searchWords(query);
+    const exactType = elements[0]?.type === terms.join('-');
+    const strong = templates.filter((t) => terms.every((w) => searchWords(`${t.template} ${t.title}`).includes(w)));
+    if (exactType || strong.length === 0)
+        return [...elements, ...templates];
+    return [...strong, ...elements, ...templates.filter((t) => !strong.includes(t))];
+}
 /**
  * What one inspector control writes.
  *
- * 118 of the 435 controls declare it in the platform's trait registry. The rest
+ * 165 of the 577 controls declare it in the platform's trait registry. The rest
  * live inside a Vue widget's prop closure, which is not machine-readable — so
  * they come back named but undescribed, with the honest reason. Saying nothing
  * would read as "this control writes nothing".
@@ -125,10 +268,23 @@ export function traitsFor(type, control) {
         }
         return { type, control, ...describeControl(control) };
     }
+    // Read from base only whatever breakpoint is asked for — sb_set routes them
+    // there, so a "tablet-only" value of one of these is the desktop value too.
+    const baseOnly = [
+        ...new Set([
+            ...Object.keys(el.defaults?.config ?? {}),
+            ...el.controls.flatMap((c) => (TRAIT_WRITES[c]?.writes ?? []).filter((w) => w.target === 'config').map((w) => w.writeKey)),
+        ]),
+    ].filter((k) => isBaseOnlyConfig(type, k));
     const declared = {};
-    for (const c of el.controls)
-        if (TRAIT_WRITES[c])
-            declared[c] = describeControl(c);
+    for (const c of el.controls) {
+        if (!TRAIT_WRITES[c])
+            continue;
+        const base = TRAIT_WRITES[c].writes.some((w) => w.target === 'config' && isBaseOnlyConfig(type, w.writeKey));
+        declared[c] = { ...describeControl(c), ...(base ? { responsive: false } : {}) };
+    }
+    const preconditions = WRITE_PRECONDITIONS.filter((p) => p.types.includes(type)).map(({ types: _, ...p }) => p);
+    const bindable = bindableFields(type);
     return {
         type: el.type,
         hints: { useWhen: el.useWhen, avoidWhen: el.avoidWhen, contentTips: el.contentTips },
@@ -137,6 +293,15 @@ export function traitsFor(type, control) {
             groups: t.groups.map((g) => ({ group: g.label, controls: g.controls })),
         })),
         declared,
+        ...(baseOnly.length ? { base_only: baseOnly } : {}),
+        // Legal apart, meaningless together — the platform's own declaration.
+        ...(preconditions.length ? { preconditions } : {}),
+        // The click actions per trigger; binding_events replaces them once the node
+        // carries a purchase binding (add_to_cart is the BINDING, never an event).
+        ...(el.events ? { events: el.events } : {}),
+        ...(el.bindingEvents ? { binding_events: el.bindingEvents } : {}),
+        // The specials a record binding may target on this element.
+        ...(bindable.length ? { bindable } : {}),
         // The keys this element actually seeds. For `config` and `specials` —
         // which, unlike `style`, are NOT open — this is the machine-readable
         // answer to "what does this element store", and often the only one.